IAM-JSON-Richtlinienelemente: Bedingungsoperatoren - AWS Identity and Access Management
Bedingungsoperatoren für ZeichenfolgenNumerische BedingungsoperatorenBedingungsoperatoren für DatumBoolesche BedingungsoperatorenBinäre BedingungsoperatorenBedingungsoperatoren für IP-AdressenBedingungsoperatoren für Amazon-Ressourcennamen (ARN)...IfExists-BedingungsoperatorenBedingungsoperator zur Prüfung der Existenz von Bedingungsoperatoren

IAM-JSON-Richtlinienelemente: Bedingungsoperatoren

Verwenden Sie Bedingungsoperatoren im Condition-Element, um den Bedingungsschlüssel und -wert in der Richtlinie mit den Werten im Anforderungskontext abzugleichen. Weitere Informationen zum Condition-Element finden Sie unter IAM-JSON-Richtlinienelemente: Condition.

Der Bedingungsoperator, den Sie in einer Richtlinie verwenden können, hängt vom ausgewählten Bedingungsschlüssel ab. Sie können einen globalen Bedingungsschlüssel oder einen servicespezifischen Bedingungsschlüssel auswählen. Informationen dazu, welchen Bedingungsoperator Sie für einen globalen Bedingungsschlüssel verwenden können, finden Sie unter AWS Globale Bedingungskontextschlüssel. Um zu erfahren, welchen Konditionsoperator Sie für einen dienstleistungsspezifischen Konditionsschlüssel verwenden können, lesen Sie Aktionen, Ressourcen und Konditionsschlüssel für AWS-Dienste und wählen Sie den Dienst, den Sie anzeigen möchten.

Wichtig

Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein und die Bedingung ist falsch. Wenn die Richtlinienbedingung erfordert, dass der Schlüssel nicht abgestimmt ist, wie StringNotLike oder ArnNotLike, und der richtige Schlüssel ist nicht vorhanden, ist die Bedingung wahr. Diese Logik gilt für alle Bedingungsoperatoren außer ...IfExists und Null-Prüfung. Diese Operatoren testen, ob der Schlüssel im Anforderungskontext vorhanden ist (existiert).

Die Bedingungsoperatoren können in folgende Kategorien gruppiert werden:

Bedingungsoperatoren für Zeichenfolgen

Mit String-Bedingungsoperatoren können Sie Condition-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem Zeichenfolgewert einschränken.

Bedingungsoperator Beschreibung

StringEquals

Exakte Übereinstimmung, Unterscheidung von Groß- und Kleinschreibung

StringNotEquals

Negierte Übereinstimmung

StringEqualsIgnoreCase

Exakte Übereinstimmung, keine Unterscheidung von Groß- und Kleinschreibung

StringNotEqualsIgnoreCase

Negierte Übereinstimmung, keine Unterscheidung von Groß- und Kleinschreibung

StringLike

Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung Die Werte können einen Mehrzeichen-Übereinstimmungs-Platzhalter (*) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) an einer beliebigen Stelle in der Zeichenfolge enthalten. Sie müssen Platzhalter angeben, um teilweise Zeichenfolgenübereinstimmungen zu erzielen.

Anmerkung

Wenn ein Schlüssel mehrere Werte enthält, kann StringLike mit den Set-Operatoren ForAllValues:StringLike und ForAnyValue:StringLike ausgewertet werden. Weitere Informationen finden Sie unter Operatoren für mehrwertige Kontextschlüssel festlegen.

StringNotLike

Negierte Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung Die Werte können einen Mehrzeichen-Übereinstimmungs-Platzhalter (*) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) an einer beliebigen Stelle in der Zeichenfolge enthalten.
Beispiel Bedingungsoperator für Zeichenfolge

Zum Beispiel enthält die folgende Anweisung ein Condition-Element, das den aws:PrincipalTag-Schlüssel verwendet, um anzugeben, dass der anfordernde Prinzipal mit der iamuser-admin-Aufgabenkategorie getaggt sein muss.

JSON
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "iam:*AccessKey*",
        "Resource": "arn:aws:iam::111122223333:user/*",
        "Condition": {
            "StringEquals": {
                "aws:PrincipalTag/job-category": "iamuser-admin"
            }
        }
    }
}

Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. In diesem Beispiel ist der Schlüssel aws:PrincipalTag/job-category im Anforderungskontext vorhanden, wenn der Auftraggeber einen IAM-Benutzer mit angehängten Tags verwendet. Er ist auch für einen Auftraggeber enthalten, der eine IAM-Rolle mit angehängten Tags oder Sitzungstags verwendet. Wenn ein Benutzer ohne das Tag versucht, einen Zugriffsschlüssel anzuzeigen oder zu bearbeiten, gibt die Bedingung false zurück und die Anforderung wird durch diese Anweisung implizit abgelehnt.

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"StringEquals": {
  "aws:PrincipalTag/job-category": "iamuser-admin"
}
 
aws:PrincipalTag/job-category:
  – iamuser-admin

Match

 
"StringEquals": {
  "aws:PrincipalTag/job-category": "iamuser-admin"
}
 
aws:PrincipalTag/job-category:
  – dev-ops

Keine Übereinstimmung

 
"StringEquals": {
  "aws:PrincipalTag/job-category": "iamuser-admin"
}

Kein aws:PrincipalTag/job-category im Anforderungskontext.

Keine Übereinstimmung
Beispiel Verwenden einer Richtlinienvariablen mit einem Bedingungsoperator für eine Zeichenfolge

Im folgenden Beispiel wird der StringLike-Bedingungsoperator verwendet, um einen String-Abgleich mit einer Richtlinienvariablen durchzuführen, um eine Richtlinie zu erstellen, die es einem IAM-Benutzer ermöglicht, die Amazon S3-Konsole zu verwenden, um sein eigenes "Heimatverzeichnis" in einem Amazon S3-Bucket zu verwalten. Die Richtlinie lässt die angegebenen Aktionen für ein S3-Bucket zu, solange s3:prefix einem angegebenen Muster entspricht.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "s3:ListAllMyBuckets",
        "s3:GetBucketLocation"
      ],
      "Resource": "arn:aws:s3:::*"
    },
    {
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
      "Condition": {
        "StringLike": {
          "s3:prefix": [
            "",
            "home/",
            "home/${aws:username}/"
          ]
        }
      }
    },
    {
      "Effect": "Allow",
      "Action": "s3:*",
      "Resource": [
        "arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}",
        "arn:aws:s3:::amzn-s3-demo-bucket/home/${aws:username}/*"
      ]
    }
  ]
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie für verschiedene Benutzer basierend auf dem aws:username-Wert im Anforderungskontext bewertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"StringLike": {
  "s3:prefix": [
    "home/",
    "home/${aws:username}/"
  ]
}
 
aws:username:
  – martha_rivera
 
"StringLike": {
  "s3:prefix": [
    "home/",
    "home/martha_rivera/"
  ]
}
 
"StringLike": {
  "s3:prefix": [
    "home/",
    "home/${aws:username}/"
  ]
}
 
aws:username:
  – nikki_wolf
 
"StringLike": {
  "s3:prefix": [
    "home/",
    "home/nikki_wolf/"
  ]
}
 
"StringLike": {
  "s3:prefix": [
    "home/",
    "home/${aws:username}/"
  ]
}

Kein aws:username im Anforderungskontext.

Keine Übereinstimmung

Ein Beispiel für eine Richtlinie zur Verwendung des Condition-Elements, um den Zugriff auf Ressourcen basierend auf einer Anwendungs-ID und einer Benutzer-ID zum OIDC-Verbund einzuschränken, finden Sie unter Amazon S3: Ermöglicht Amazon Cognito-Benutzern den Zugriff auf Objekte in ihrem Bucket.

Mehrwertige Bedingungsoperatoren für Zeichenfolgen

Wenn ein Schlüssel in der Anforderung mehrere Werte enthält, können Zeichenfolgenoperatoren mit den Set-Operatoren ForAllValues und ForAnyValue qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter Operatoren für mehrwertige Kontextschlüssel festlegen.

Bedingungsoperator Beschreibung

ForAllValues:StringEquals

ForAllValues:StringEqualsIgnoreCase

Alle Werte für den Bedingungsschlüssel in der Anforderung müssen mit mindestens einem der Werte in Ihrer Richtlinie übereinstimmen.

ForAnyValue:StringEquals

ForAnyValue:StringEqualsIgnoreCase

Mindestens ein Bedingungsschlüsselwert in der Anforderung muss mit einem der Werte in Ihrer Richtlinie übereinstimmen.

ForAllValues:StringNotEquals

ForAllValues:StringNotEqualsIgnoreCase

Negierte Übereinstimmung.

Keiner der Werte des Kontextschlüssels in der Anforderung stimmt mit einem der Kontextschlüsselwerte in Ihrer Richtlinie überein.

ForAnyValue:StringNotEquals

ForAnyValue:StringNotEqualsIgnoreCase

Negierte Übereinstimmung.

Mindestens ein Kontextschlüsselwert in der Anforderung darf mit KEINEM der Werte im Kontextschlüssel Ihrer Richtlinie übereinstimmen.

ForAllValues:StringLike

Alle Werte für den Bedingungsschlüssel in der Anforderung müssen mit mindestens einem der Werte in Ihrer Richtlinie übereinstimmen.

ForAnyValue:StringLike

Mindestens ein Bedingungsschlüsselwert in der Anforderung muss mit einem der Werte in Ihrer Richtlinie übereinstimmen.

ForAllValues:StringNotLike

Negierte Übereinstimmung.

Keiner der Werte des Kontextschlüssels in der Anforderung stimmt mit einem der Kontextschlüsselwerte in Ihrer Richtlinie überein.

ForAnyValue:StringNotLike

Negierte Übereinstimmung.

Mindestens ein Kontextschlüsselwert in der Anforderung darf mit KEINEM der Werte im Kontextschlüssel Ihrer Richtlinie übereinstimmen.
Beispiel Verwenden von ForAnyValue mit einem Bedingungsoperator für eine Zeichenfolge

Dieses Beispiel zeigt, wie Sie eine identitätsbasierte Richtlinie erstellen können, die es erlaubt, mithilfe der Amazon-EC2-Aktion CreateTags Tags an eine Instance anzuhängen. Wenn Sie StringEqualsIgnoreCase verwenden, können Sie Tags nur anhängen, wenn das Tag den environment-Schlüssel mit dem Wert preprod oder storage enthält. Wenn Sie IgnoreCase an den Operator anhängen, erlauben Sie, dass alle vorhandenen Tag-Werte, die großgeschrieben sind, wie preprod, Preprod und PreProd, als „true“ aufgelöst werden.

Wenn Sie den Modifikator ForAnyValue mit dem Bedingungsschlüssel aws:TagKeys hinzufügen, muss mindestens ein Tag-Schlüsselwert in der Anfrage mit dem Wert environment übereinstimmen. Bei der ForAnyValue-Vergleichsfunktion wird zwischen Groß- und Kleinschreibung unterschieden, wodurch verhindert wird, dass Benutzer eine falsche Groß-/Kleinschreibung für den Tag-Schlüssel verwenden, z. B. Environment statt environment.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "ec2:CreateTags",
    "Resource": "arn:aws:ec2:*:*:instance/*",
    "Condition": {
      "StringEqualsIgnoreCase": {
        "aws:RequestTag/environment": [
          "preprod",
          "storage"
        ]
      },
      "ForAnyValue:StringEquals": {
        "aws:TagKeys": "environment"
      }
    }
  }
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}
 
aws:TagKeys:
  – environment
aws:RequestTag/environment:
  – preprod

Match

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}
 
aws:TagKeys:
  – environment
  – costcenter
aws:RequestTag/environment:
  – PreProd

Match

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}
 
aws:TagKeys:
  – Environment
aws:RequestTag/Environment:
  – preprod

Keine Übereinstimmung

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}
 
aws:TagKeys:
  – costcenter
aws:RequestTag/environment:
  – preprod

Keine Übereinstimmung

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}

Kein aws:TagKeys im Anforderungskontext.

aws:RequestTag/environment:
  – storage

Keine Übereinstimmung

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}
 
aws:TagKeys:
  – environment

Kein aws:RequestTag/environment im Anforderungskontext.

Keine Übereinstimmung

 
"StringEqualsIgnoreCase": {
  "aws:RequestTag/environment": [
    "preprod",
    "storage"
  ]
},
"ForAnyValue:StringEquals": {
  "aws:TagKeys": "environment"
}

Kein aws:TagKeys im Anforderungskontext.

Kein aws:RequestTag/environment im Anforderungskontext.

Keine Übereinstimmung

Platzhalterabgleich

Operatoren für Zeichenfolgenbedingungen führen einen musterlosen Abgleich durch, der kein vordefiniertes Format erzwingt. Die Bedingungsoperatoren ARN und Datum sind eine Teilmenge von Zeichenfolgenoperatoren, die eine Struktur für den Bedingungsschlüsselwert erzwingen.

Wir empfehlen Ihnen, Bedingungsoperatoren zu verwenden, die den Werten entsprechen, mit denen Sie die Schlüssel vergleichen. Beispielsweise sollten Sie beim Vergleichen von Schlüsseln mit Zeichenfolgenwerten Bedingungsoperatoren für Zeichenfolgen verwenden. Ebenso sollten Sie Bedingungsoperatoren für Amazon-Ressourcennamen (ARN) verwenden, wenn Sie Schlüssel mit ARN-Werten vergleichen.

Dieses Beispiel zeigt, wie Sie eine Grenze um Ressourcen in Ihrer Organisation erstellen können. Die Bedingung in dieser Richtlinie verweigert den Zugriff auf Amazon-S3-Aktionen, es sei denn, die Ressource, auf die zugegriffen wird, befindet sich in einer bestimmten Gruppe von Organisationseinheiten (OUs) in AWS Organizations. Ein AWS Organizations-Pfad ist eine textuelle Darstellung der Struktur einer Organisationseinheit.

Die Bedingung setzt voraus, dass aws:ResourceOrgPaths einen der aufgelisteten OU-Pfade enthält. Da aws:ResourceOrgPaths eine mehrwertige Bedingung ist, verwendet die Richtlinie den Operator ForAllValues:StringNotLike, um die Werte von aws:ResourceOrgPaths mit der Liste der OUs in der Richtlinie zu vergleichen.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "DenyS3AccessOutsideMyBoundary",
      "Effect": "Deny",
      "Action": [
        "s3:*"
      ],
      "Resource": "*",
      "Condition": {
        "ForAllValues:StringNotLike": {
          "aws:ResourceOrgPaths": [
            "o-acorg/r-acroot/ou-acroot-mediaou/",
            "o-acorg/r-acroot/ou-acroot-sportsou/*"
          ] 
        }
      }
    }
  ]
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"ForAllValues:StringNotLike": {
  "aws:ResourceOrgPaths": [
    "o-acorg/r-acroot/ou-acroot-mediaou/",
    "o-acorg/r-acroot/ou-acroot-sportsou/*"
  ] 
}
 
aws:ResourceOrgPaths:
  – o-acorg/r-acroot/ou-acroot-sportsou/costcenter/

Match

 
"ForAllValues:StringNotLike": {
  "aws:ResourceOrgPaths": [
    "o-acorg/r-acroot/ou-acroot-mediaou/",
    "o-acorg/r-acroot/ou-acroot-sportsou/*"
  ] 
}
 
aws:ResourceOrgPaths:
  – o-acorg/r-acroot/ou-acroot-mediaou/costcenter/

Keine Übereinstimmung

 
"ForAllValues:StringNotLike": {
  "aws:ResourceOrgPaths": [
    "o-acorg/r-acroot/ou-acroot-mediaou/",
    "o-acorg/r-acroot/ou-acroot-sportsou/*"
  ] 
}

Kein aws:ResourceOrgPaths: in der Anforderung.

Keine Übereinstimmung

Numerische Bedingungsoperatoren

Mit numerischen Bedingungsoperatoren können Sie Condition-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem Ganzzahl- oder Dezimalzahlwert einschränken.

  • Richtlinienvariablen: nicht unterstützt

  • Platzhalter: nicht unterstützt

Bedingungsoperator Beschreibung

NumericEquals

Übereinstimmung

NumericNotEquals

Negierte Übereinstimmung

NumericLessThan

Übereinstimmung "Kleiner als"

NumericLessThanEquals

Übereinstimmung "Kleiner als oder gleich"

NumericGreaterThan

Übereinstimmung "Größer als"

NumericGreaterThanEquals

Übereinstimmung "Größer als oder gleich"

Die folgende Anweisung enthält beispielsweise ein Condition-Element, das den Bedingungsoperator NumericLessThanEquals mit dem Schlüssel s3:max-keys enthält, um anzugeben, dass der Anforderer bis zu 10 Objekte gleichzeitig im amzn-s3-demo-bucket aufnehmen kann.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "s3:ListBucket",
    "Resource": "arn:aws:s3:::amzn-s3-demo-bucket",
    "Condition": {"NumericLessThanEquals": {"s3:max-keys": "10"}}
  }
}

Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. In diesem Beispiel ist der s3:max-keys-Schlüssel immer in der Anforderung vorhanden, wenn Sie die Operation ListBucket ausführen. Wenn diese Richtlinie alle Amazon S3-Operationen zulässt, sind nur die Operationen zulässig, die den max-keys-Kontextschlüssel mit einem Wert von kleiner oder gleich 10 enthalten.

Bedingungsoperatoren für Datum

Mit Date-Bedingungsoperatoren können Sie Condition-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem Datums-/Uhrzeitwert einschränken. Diese Bedingungsoperatoren werden mit dem Schlüssel aws:CurrentTime oder aws:EpochTime verwendet. Sie müssen die Datums-/Uhrzeitwerte unter Beachtung der W3C-Implementierungen der Datumsformate gemäß ISO 8601 oder in Epoch-Zeit (UNIX) angeben.

  • Richtlinienvariablen: nicht unterstützt

  • Platzhalter: nicht unterstützt

Bedingungsoperator Beschreibung

DateEquals

Übereinstimmung mit einem bestimmten Datum

DateNotEquals

Negierte Übereinstimmung

DateLessThan

Übereinstimmung vor einem bestimmten Datum und einer bestimmten Uhrzeit

DateLessThanEquals

Übereinstimmung an oder vor einem bestimmten Datum und oder einer bestimmten Uhrzeit

DateGreaterThan

Übereinstimmung nach einem bestimmten Datum und einer bestimmten Uhrzeit

DateGreaterThanEquals

Übereinstimmung an oder nach einem bestimmten Datum und einer bestimmten Uhrzeit

Beispielsweise enthält die folgende Anweisung ein Condition-Element, das den Bedingungsoperator DateGreaterThan mit dem aws:TokenIssueTime-Schlüssel verwendet. Diese Bedingung gibt an, dass die temporären Sicherheitsanmeldeinformationen, die für die Anforderung verwendet wurden, im Jahr 2020 ausgegeben wurden. Diese Richtlinie kann täglich programmgesteuert aktualisiert werden, um sicherzustellen, dass Kontomitglieder neue Anmeldeinformationen verwenden.

JSON
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "iam:*AccessKey*",
        "Resource": "arn:aws:iam::111122223333:user/*",
        "Condition": {
            "DateGreaterThan": {
                "aws:TokenIssueTime": "2020-01-01T00:00:01Z"
            }
        }
    }
}

Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. Der aws:TokenIssueTime-Schlüssel ist im Anforderungskontext nur dann vorhanden, wenn der Auftraggeber temporäre Anmeldeinformationen für die Anforderung verwendet. Der Schlüssel ist in AWS CLI-, AWS-API- oder AWS-SDK-Anforderungen, die mit Zugriffsschlüsseln gestellt werden, nicht vorhanden. Wenn in diesem Beispiel ein IAM-Benutzer versucht, einen Zugriffsschlüssel anzuzeigen oder zu bearbeiten, wird die Anforderung verweigert.

Boolesche Bedingungsoperatoren

Mit booleschen Bedingungsoperatoren können Sie Condition-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit true oder false einschränken.

Wenn ein Schlüssel mehrere Werte enthält, können boolesche Operatoren mit den Set-Operatoren ForAllValues und ForAnyValue qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter Operatoren für mehrwertige Kontextschlüssel festlegen.

  • Richtlinienvariablen: unterstützt

  • Platzhalter: nicht unterstützt

Bedingungsoperator Beschreibung

Bool

Boolesche Übereinstimmung

ForAllValues:Bool

Verwendung mit dem Datentyp „Array of Bool“. Alle Booleschen Werte in den Kontextschlüsselwerten müssen mit den Booleschen Werten in Ihrer Richtlinie übereinstimmen.

Um zu verhindern, dass ForAllValues-Operatoren fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „Zulässig“ auswerten, können Sie den Null-Bedingungsoperator in Ihre Richtlinie aufnehmen.

ForAnyValue:Bool

Verwendung mit dem Datentyp „Array of Bool“. Mindestens einer der Booleschen Werte in den Kontextschlüsselwerten müssen mit den Booleschen Werten in Ihrer Richtlinie übereinstimmen.
Beispiel Boolescher Bedingungsoperator

Die folgende identitätsbasierte Richtlinie verwendet den Bool-Bedingungsoperator mit dem aws:SecureTransport-Schlüssel, um die Replikation von Objekten und Objekt-Tags in den Ziel-Bucket und dessen Inhalt zu verweigern, wenn die Anforderung nicht über SSL erfolgt.

Wichtig

Diese Richtlinie lässt keine Aktionen zu. Verwenden Sie diese Richtlinie in Kombination mit anderen Richtlinien, die bestimmte Aktionen zulassen.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "BooleanExample",
      "Action": "s3:ReplicateObject",
      "Effect": "Deny",
      "Resource": [
        "arn:aws:s3:::amzn-s3-demo-bucket",
        "arn:aws:s3:::amzn-s3-demo-bucket/*"
      ],
      "Condition": {
        "Bool": {
          "aws:SecureTransport": "false"
        }
      }
    }
  ]
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"Bool": {
  "aws:SecureTransport": "false"
}
 
aws:SecureTransport:
  – false

Match

 
"Bool": {
  "aws:SecureTransport": "false"
}
 
aws:SecureTransport:
  – true

Keine Übereinstimmung

 
"Bool": {
  "aws:SecureTransport": "false"
}

Kein aws:SecureTransport im Anforderungskontext.

Keine Übereinstimmung

Binäre Bedingungsoperatoren

Mit dem Bedingungsoperator BinaryEquals können Sie Condition-Elemente zum Prüfen von binären Schlüsselwerten erstellen. Er vergleicht den Wert des angegebenen Schlüssel Byte für Byte mit einer base-64-kodierten Darstellung des Binärwertes in der Richtlinie. Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein.

  • Richtlinienvariablen: nicht unterstützt

  • Platzhalter: nicht unterstützt

"Condition" : {
  "BinaryEquals": {
    "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
  }
}
Richtlinienbedingung Kontext anfordern Ergebnis 
"BinaryEquals": {
  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
 
key:
  – QmluYXJ5VmFsdWVJbkJhc2U2NA==

Match

 
"BinaryEquals": {
  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}
 
key:
  – ASIAIOSFODNN7EXAMPLE

Keine Übereinstimmung

 
"BinaryEquals": {
  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="
}

Kein key im Anforderungskontext.

Keine Übereinstimmung

Bedingungsoperatoren für IP-Adressen

Mit Bedingungsoperatoren für IP-Adressen können Sie Condition-Elemente erstellen, die den Zugriff anhand des Vergleichs eines Schlüssels mit einer IPv4- oder IPv6-Adresse bzw. einen IP-Adressbereich einschränken. Verwenden Sie sie mit dem Schlüssel aws:SourceIp. Der Wert muss im CIDR-Standardformat ausgedrückt werden (z. B. 203.0.113.0/24 oder 2001:DB8:1234:5678::/64). Wenn Sie eine IP-Adresse ohne das zugehörige Routing-Präfix zuweisen, verwendet IAM den Standard-Präfixwert /32.

Einige AWS-Services unterstützen IPv6 unter Verwendung von ::, um eine Reihe von Nullen darzustellen. Um zu erfahren, ob ein Service IPv6 unterstützt, finden Sie in der Dokumentation des jeweiligen Service.

  • Richtlinienvariablen: nicht unterstützt

  • Platzhalter: nicht unterstützt

Bedingungsoperator Beschreibung

IpAddress

Die angegebene IP-Adresse oder der angegebene IP-Bereich

NotIpAddress

Alle IP-Adressen mit Ausnahme der angegebenen IP-Adresse oder des angegebenen IP-Bereichs.
Beispiel Bedingungsoperator für IP-Adressen

In der folgenden Anweisung wird der Bedingungsoperator IpAddress mit dem Schlüssel aws:SourceIp verwendet, um anzugeben, dass die Anforderung von einer IP-Adresse zwischen 203.0.113.0 und 203.0.113.255 kommen muss.

JSON
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "iam:*AccessKey*",
        "Resource": "arn:aws:iam::111122223333:user/*",
        "Condition": {
            "IpAddress": {
                "aws:SourceIp": "203.0.113.0/24"
            }
        }
    }
}

Der Bedingungsschlüssel aws:SourceIp wird auf die IP-Adresse aufgelöst, von der die Anforderung kommt. Wenn die Anforderungen aus einer Amazon EC2-Instance kommen, gibt aws:SourceIp die öffentliche IP-Adresse der Instance zurück.

Wenn der Schlüssel, den Sie in einer Richtlinienbedingung angeben, im Anforderungskontext nicht vorhanden ist, stimmen die Werte nicht überein. Der aws:SourceIp-Schlüssel ist immer im Anforderungskontext vorhanden, außer wenn der Anforderer einen VPC-Endpunkt für die Anforderung verwendet. In diesem Fall gibt die Bedingung false zurück und die Anforderung wird durch diese Anweisung implizit abgelehnt.

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"IpAddress": {
  "aws:SourceIp": "203.0.113.0/24"
}
 
aws:SourceIp:
  – 203.0.113.1

Match

 
"IpAddress": {
  "aws:SourceIp": "203.0.113.0/24"
}
 
aws:SourceIp:
  – 198.51.100.1

Keine Übereinstimmung

Im folgenden Beispiel wird dargestellt, wie Sie IPv4- und IPv6-Adressen verwenden können, um alle gültigen IP-Adressen in Ihrer Organisation abzudecken. Wir empfehlen, dass Sie die Richtlinien Ihrer Organisation zusätzlich zu den bereits vorhandenen IPv4-Adressbereichen um Ihre IPv6-Adressbereiche aktualisieren, um die Funktion Ihrer Richtlinien während der Umstellung auf IPv6 sicherzustellen.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "someservice:*",
    "Resource": "*",
    "Condition": {
      "IpAddress": {
        "aws:SourceIp": [
          "203.0.113.0/24",
          "2001:DB8:1234:5678::/64"
        ]
      }
    }
  }
}

Der Bedingungsschlüssel aws:SourceIp funktioniert in einer JSON-Richtlinie nur, wenn Sie die geprüfte API direkt als Benutzer aufrufen. Wenn Sie stattdessen einen Service verwenden, um den Zielservice in Ihrem Namen aufzurufen, erkennt der Zielservice die IP-Adresse des aufrufenden Services und nicht die IP-Adresse des verursachenden Benutzers. Das kann passieren, wenn Sie beispielsweise AWS CloudFormation zum Aufrufen von Amazon EC2 aufrufen, um in Ihrem Namen Instances zu erstellen. Derzeit gibt es keine Möglichkeit, die ursprüngliche IP-Adresse über einen Aufrufservice an den Zielservice zur Bewertung in einer JSON-Richtlinie zu übermitteln. Verwenden Sie für diese Art von Service-API-Aufrufen nicht den Bedingungsschlüssel aws:SourceIp.

Bedingungsoperatoren für Amazon-Ressourcennamen (ARN)

Mit den Bedingungsoperatoren für Amazon-Ressourcennamen (ARN) können Sie Condition-Elemente erstellen, die den Zugriff basierend auf einen Vergleich eines Schlüssels mit einem ARN einschränken. Der ARN wird als Zeichenfolge interpretiert.

Bedingungsoperator Beschreibung

ArnEquals, ArnLike

Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung des ARN Jede der sechs durch Doppelpunkt getrennten Komponenten der ARN wird separat überprüft und alle Komponenten können Mehrzeichen-Übereinstimmungs-Platzhalter (*) oder einen Einzelzeichen-Übereinstimmungs-Platzhalter (?) enthalten. Die ArnEquals- und ArnLike-Bedingungsoperatoren verhalten sich identisch.

ArnNotEquals, ArnNotLike

Negierte Übereinstimmung von ARN DieArnNotEquals- undArnNotLike-Bedingungsoperatoren verhalten sich identisch.
Beispiel ARN-Bedingungsoperator

Das folgende ressourcenbasierte Richtlinienbeispiel zeigt eine Richtlinie, die einer Amazon SQS-Warteschlange zugeordnet ist, an die Sie SNS-Nachrichten senden möchten. Es gibt Amazon SNS die Erlaubnis, Nachrichten an die Warteschlange (oder Warteschlangen) Ihrer Wahl zu senden, aber nur, wenn der Service die Nachrichten im Namen eines bestimmten Amazon SNS-Themas (oder Themen) sendet. Geben Sie die Warteschlange im Feld Resource und das Amazon SNS-Thema als Wert für den Schlüssel SourceArn an.

JSON
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Principal": {
            "Service": "sns.amazonaws.com"
        },
        "Action": "SQS:SendMessage",
        "Resource": "arn:aws:sqs:us-east-1:123456789012:QUEUE-ID",
        "Condition": {
            "ArnEquals": {
                "aws:SourceArn": "arn:aws:sns:us-east-1:123456789012:TOPIC-ID"
            }
        }
    }
}

Der aws:SourceArn-Schlüssel ist im Anforderungskontext nur dann vorhanden, wenn eine Ressource einen Service auslöst, um einen anderen Service im Namen des Ressourcenbesitzers aufzurufen. Wenn ein IAM-Benutzer versucht, diesen Vorgang direkt auszuführen, kehrt die Bedingung false zurück und die Anforderung wird implizit durch diese Anweisung abgelehnt.

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"ArnEquals": {
  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
}
 
aws:SourceArn:
  – arn:aws:sns:us-west-2:123456789012:TOPIC-ID

Match

 
"ArnEquals": {
  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
}
 
aws:SourceArn:
  – arn:aws:sns:us-west-2:777788889999:TOPIC-ID

Keine Übereinstimmung

 
"ArnEquals": {
  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"
}

Kein aws:SourceArn im Anforderungskontext.

Keine Übereinstimmung

Mehrwertige ARN-Bedingungsoperatoren

Wenn ein Schlüssel in der Anforderung mehrere Werte enthält, können ARN-Operatoren mit den Set-Operatoren ForAllValues und ForAnyValue qualifiziert werden. Weitere Informationen zur Auswertungslogik mehrerer Kontextschlüssel oder -werte finden Sie unter Operatoren für mehrwertige Kontextschlüssel festlegen.

Bedingungsoperator Beschreibung

ForAllValues:ArnEquals

ForAllValues:ArnLike

Alle ARNs im Anforderungskontext müssen mit mindestens einem der ARN-Muster in Ihrer Richtlinie übereinstimmen.

ForAnyValue:ArnEquals

ForAnyValue:ArnLike

Mindestens ein ARN im Anforderungskontext muss mit einem der ARN-Muster in Ihrer Richtlinie übereinstimmen.

ForAllValues:ArnNotEquals

ForAllValues:ArnNotLike

Negierte Übereinstimmung.

Keine der ARNs im Anforderungskontext kann mit einem der Zeichenfolgen-ARN-Muster in Ihrer Richtlinie übereinstimmen.

ForAnyValue:ArnNotEquals

ForAnyValue:ArnNotLike

Negierte Übereinstimmung.

Mindestens ein ARN im Anforderungskontext darf NICHT mit einem der ARN-Muster in Ihrer Richtlinie übereinstimmen.
Beispiel Verwenden von ForAllValues mit einem ARN-Bedingungsoperator

Im folgenden Beispiel wird ForAllValues:ArnLike verwendet, um eine logische Lieferquelle für Protokolle in Amazon CloudWatch Logs zu erstellen oder zu aktualisieren. Der Bedingungsblock enthält den Bedingungsschlüssel logs:LogGeneratingResourceArns, um die in der Anforderung übergebenen ARNs der protokollgenerierenden Ressource zu filtern. Bei Verwendung dieses Bedingungsoperators müssen alle ARNs in der Anfrage mindestens einem ARN in der Richtlinie entsprechen.

JSON
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": "*",
            "Action": "logs:PutDeliverySource",
            "Resource": "arn:aws:logs:us-east-1:123456789012:delivery-source:*",
            "Condition": {
                "ForAllValues:ArnLike": {
                    "logs:LogGeneratingResourceArns": [
                        "arn:aws:cloudfront::123456789012:distribution/*",
                        "arn:aws:cloudfront::123456789012:distribution/support*"
                    ]
                }
            }
        }
    ]
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"ForAllValues:ArnLike": {
  "logs:LogGeneratingResourceArns": [
    "arn:aws::cloudfront:123456789012:distribution/*",
    "arn:aws::cloudfront:123456789012:distribution/support*"
  ]
}
 
logs:LogGeneratingResourceArns:
  – arn:aws::cloudfront:123456789012:distribution/costcenter

Match

 
"ForAllValues:ArnLike": {
  "logs:LogGeneratingResourceArns": [
    "arn:aws::cloudfront:123456789012:distribution/*",
    "arn:aws::cloudfront:123456789012:distribution/support*"
  ]
}
 
logs:LogGeneratingResourceArns:
  – arn:aws::cloudfront:123456789012:distribution/costcenter
  – arn:aws::cloudfront:123456789012:distribution/support2025

Match

 
"ForAllValues:ArnLike": {
  "logs:LogGeneratingResourceArns": [
    "arn:aws::cloudfront:123456789012:distribution/*",
    "arn:aws::cloudfront:123456789012:distribution/support*"
  ]
}
 
logs:LogGeneratingResourceArns:
  – arn:aws::cloudfront:123456789012:distribution/costcenter
  – arn:aws::cloudfront:123456789012:distribution/admin

Keine Übereinstimmung

 
"ForAllValues:ArnLike": {
  "logs:LogGeneratingResourceArns": [
    "arn:aws::cloudfront:123456789012:distribution/*",
    "arn:aws::cloudfront:123456789012:distribution/support*"
  ]
}
 
logs:LogGeneratingResourceArns:
  – arn:aws::cloudfront:777788889999:distribution/costcenter

Keine Übereinstimmung

 
"ForAllValues:ArnLike": {
  "logs:LogGeneratingResourceArns": [
    "arn:aws::cloudfront:123456789012:distribution/*",
    "arn:aws::cloudfront:123456789012:distribution/support*"
  ]
}

Kein logs:LogGeneratingResourceArns im Anforderungskontext.

Match

Der Qualifizierer ForAllValues gibt „true“ zurück, wenn die Anforderung keine Kontextschlüssel enthält oder wenn der Wert des Kontextschlüssels zu einem Null-Datensatz aufgelöst wird, z. B. einer leeren Zeichenfolge. Um zu verhindern, dass fehlende Kontextschlüssel oder Kontextschlüssel mit leeren Werten als „true“ ausgewertet werden, können Sie den Null-Bedingungsoperator mit einem false-Wert in Ihre Richtlinie aufnehmen, um zu überprüfen, ob der Kontextschlüssel vorhanden ist und sein Wert nicht null ist.

...IfExists-Bedingungsoperatoren

Sie können IfExists an das Ende jedes Bedingungsoperatornamens hinzufügen, abgesehen von der Null-Bedingung wie z. B. StringLikeIfExists. Damit geben Sie zum Ausdruck: „Wenn der Bedingungsschlüssel im Kontext der Anfrage vorhanden ist, verarbeiten Sie den Schlüssel wie in der Richtlinie angegeben.“ Wenn der Schlüssel nicht vorhanden ist, wird das Bedingungselement als "true" ausgewertet. Andere Bedingungselemente in der Anweisung können weiterhin zu einer Nichtübereinstimmung führen, nicht jedoch ein fehlender Schlüssel bei einer Prüfung mit ...IfExists. Wenn Sie ein "Effect": "Deny"-Element mit einem negierten Bedingungsoperator wie StringNotEqualsIfExists verwenden, wird die Anfrage dennoch abgelehnt, auch wenn der Bedingungsschlüssel nicht vorhanden ist.

Beispiel mit IfExists

Viele Bedingungsschlüssel beschreiben einen bestimmten Ressourcentyp und existieren nur beim Zugriff auf diesen Ressourcentyp. Diese Bedingungsschlüssel sind bei anderen Ressourcentypen nicht vorhanden. Dies stellt kein Problem dar, wenn die Richtlinienanweisung nur für einen Ressourcentyp gültig ist. Es gibt jedoch Fälle, bei denen eine einzelne Anweisung auf mehrere Ressourcentypen zutrifft, wenn beispielsweise die Richtlinienanweisung auf Aktionen aus mehreren Services Bezug nimmt oder wenn eine bestimmte Aktion innerhalb eines Services auf mehrere verschiedene Ressourcentypen in demselben Service zugreift. In solchen Fällen kann ein nur für eine Ressource gültiger Bedingungsschlüssel in einer Richtlinienanweisung dazu führen, dass das Element Condition in der Richtlinienanweisung fehlschlägt, sodass der "Effect" der Anweisung nicht angewendet wird.

Betrachten Sie beispielsweise das folgende einfache Richtlinienbeispiel:

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Sid": "THISPOLICYDOESNOTWORK",
    "Effect": "Allow",
    "Action": "ec2:RunInstances",
    "Resource": "*",
    "Condition": {"StringLike": {"ec2:InstanceType": [
      "t1.*",
      "t2.*",
      "m3.*"
    ]}}
  }
}

Der Zweck der vorangegangenen Richtlinie besteht darin, den Benutzer zum Starten einer beliebigen Instance vom Typ t1, t2 oder m3 zu befähigen. Zum Starten einer Instance ist jedoch auch der Zugriff auf viele Ressourcen zusätzlich zu der Instance selbst erforderlich, wie z. B. Images, Schlüsselpaare, Sicherheitsgruppen usw. Die gesamte Anweisung wird gegen alle Ressourcen geprüft, die zum Starten der Instance erforderlich sind. Diese zusätzlichen Ressourcen verfügen nicht über den Bedingungsschlüssel ec2:InstanceType, sodass die Prüfung StringLike fehlschlägt und der Benutzer nicht zum Starten eines beliebigen Instance-Typs befähigt wird.

Um dieses Problem zu beheben, verwenden Sie stattdessen den Bedingungsoperator StringLikeIfExists. Auf diese Weise findet die Prüfung nur dann statt, wenn der Bedingungsschlüssel existiert. Sie können nachstehende Richtlinie folgendermaßen interpretieren: „Wenn die zu prüfende Ressource den Bedingungsschlüssel „ec2:InstanceType„ enthält, wird die Aktion nur zugelassen, wenn der Schlüsselwert mit t1., t2. oder m3. beginnt.“ Wenn die zu prüfende Ressource nicht über diesen Bedingungsschlüssel verfügt, ist dies belanglos." Das Sternchen (*) in den Bedingungsschlüsselwerten wird, wenn es mit dem StringLikeIfExists-Bedingungsoperator verwendet wird, als Platzhalter interpretiert, um teilweise übereinstimmende Zeichenfolgen zu erzielen. Die Anweisung DescribeActions enthält die Aktionen, die erforderlich sind, um die Instance in der Konsole anzeigen.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Sid": "RunInstance",
      "Effect": "Allow",
      "Action": "ec2:RunInstances",
      "Resource": "*",
      "Condition": {
        "StringLikeIfExists": {
          "ec2:InstanceType": [
            "t1.*",
            "t2.*",
            "m3.*"
          ]
        }
      }
    },
    {
      "Sid": "DescribeActions",
      "Effect": "Allow",
      "Action": [
        "ec2:DescribeImages",
        "ec2:DescribeInstances",
        "ec2:DescribeVpcs",
        "ec2:DescribeKeyPairs",
        "ec2:DescribeSubnets",
        "ec2:DescribeSecurityGroups"
      ],
      "Resource": "*"
    }
  ]
}

Die folgende Tabelle zeigt, wie AWS diese Richtlinie auf der Grundlage der Bedingungsschlüsselwerte in Ihrer Anforderung auswertet.

Richtlinienbedingung Kontext anfordern Ergebnis 
"StringLikeIfExists": {
  "ec2:InstanceType": [
    "t1.*",
    "t2.*",
    "m3.*"
  ]
}
 
ec2:InstanceType:
  – t1.micro

Match

 
"StringLikeIfExists": {
  "ec2:InstanceType": [
    "t1.*",
    "t2.*",
    "m3.*"
  ]
}
 
ec2:InstanceType:
  – m2.micro

Keine Übereinstimmung

 
"StringLikeIfExists": {
  "ec2:InstanceType": [
    "t1.*",
    "t2.*",
    "m3.*"
  ]
}

Kein ec2:InstanceType im Anforderungskontext.

Match

Bedingungsoperator zur Prüfung der Existenz von Bedingungsoperatoren

Verwenden Sie einen Bedingungsoperator Null, um zu prüfen, ob ein Bedingungsschlüssel zum Zeitpunkt der Autorisierung abwesend ist. Verwenden Sie in der Richtlinienanweisung entweder true (der Schlüssel ist nicht vorhanden – der Wert beträgt null) oder false (der Schlüssel ist vorhanden und sein Wert ist ungleich null).

Sie können eine Richtlinienvariable mit dem NullBedingungsoperator verwenden.

Beispielsweise können Sie diesen Bedingungsoperator verwenden, um festzustellen, ob ein Benutzer temporäre Anmeldeinformationen oder seine eigenen verwendet, um eine Anforderung zu stellen. Wenn der Benutzer temporäre Anmeldeinformationen benutzt, ist der Schlüssel aws:TokenIssueTime vorhanden und hat einen Wert. Das folgende Beispiel zeigt eine Bedingung, die besagt, dass der Benutzer temporäre Anmeldeinformationen verwenden muss (der Schlüssel darf nicht fehlen), damit er die Amazon-EC2-API verwenden kann.

JSON
{
  "Version":"2012-10-17",		 	 	 
  "Statement":{
      "Action":"ec2:*",
      "Effect":"Allow",
      "Resource":"*",
      "Condition":{"Null":{"aws:TokenIssueTime":"false"}}
  }
}