# IAM JSON 策略元素：条件运算符
<a name="reference_policies_elements_condition_operators"></a>

<a name="topiclist"></a>

在 `Condition` 元素中使用条件运算符来将策略中的条件键和值与请求上下文中的值进行匹配。有关 `Condition` 元素的更多信息，请参阅 [IAM JSON 策略元素：Condition](reference_policies_elements_condition.md)。

您可以在策略中使用的条件运算符取决于您选择的条件键。您可以选择全局条件键或特定于服务的条件键。要了解可用于全局条件键的条件运算符，请参阅[AWS 全局条件上下文密钥](reference_policies_condition-keys.md)。要了解可用于特定于服务的条件键的条件运算符，请参阅 [AWS 服务的操作、资源和条件键](reference_policies_actions-resources-contextkeys.html)并选择要查看的服务。

**重要**  
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配，并且条件为 *false*。如果策略条件要求该键为*不*匹配，如 `StringNotLike` 或 `ArnNotLike`，并且右键不存在，则条件为 *true*。此逻辑适用于所有条件运算符，但 [...IfExists](#Conditions_IfExists) 和 [Null check](#Conditions_Null) 除外。这些运算符测试请求上下文中是否存在 (exists) 键。

条件运算符可分为以下类别：
+ [String](#Conditions_String)
+ [数值](#Conditions_Numeric)
+ [日期和时间](#Conditions_Date)
+ [布尔值](#Conditions_Boolean)
+ [二进制](#Conditions_BinaryEquals)
+ [IP 地址](#Conditions_IPAddress)
+ [Amazon Resource Name (ARN)](#Conditions_ARN)（仅适用于某些服务。）
+ [… IfExists](#Conditions_IfExists)（检查密钥值是否作为另一检查的一部分存在）
+ [空检查](#Conditions_Null)（检查密钥值是否作为独立检查存在）

## 字符串条件运算符
<a name="Conditions_String"></a>

利用字符串条件运算符，您可以构建基于键与字符串值的对比来限制访问的 `Condition` 元素。
+  **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - [支持](#Conditions_String-wildcard)


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `StringEquals`   |  精确匹配，区分大小写  | 
|   `StringNotEquals`   |  否定匹配  | 
|   `StringEqualsIgnoreCase`   |  精确匹配，忽略大小写  | 
|   `StringNotEqualsIgnoreCase`   |  否定匹配，忽略大小写  | 
|   `StringLike`   | 区分大小写的匹配。值可以在字符串中的任何位置包括多字符匹配的通配符（\$1）和单字符匹配的通配符（?）。您必须指定通配符才能实现部分字符串匹配。  如果一个键包含多个值，则 `StringLike` 可以用集合运算符（`ForAllValues:StringLike` 和 `ForAnyValue:StringLike`）来限定。有关更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。  | 
|   `StringNotLike`   |  不区分大小写的无效匹配。值可以在字符串中的任何位置包括多字符匹配的通配符（\$1）或单字符匹配的通配符（?）。  | 

**Example 字符串条件运算符**  
例如，以下语句包含一个 `Condition` 元素，该元素使用 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-principaltag) 键来指定必须将发出请求的主体为 `iamuser-admin` 作业类别。    
****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": {
        "Effect": "Allow",
        "Action": "iam:*AccessKey*",
        "Resource": "arn:aws:iam::111122223333:user/*",
        "Condition": {
            "StringEquals": {
                "aws:PrincipalTag/job-category": "iamuser-admin"
            }
        }
    }
}
```
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。在此示例中，当主体使用附加了标签的 IAM 用户时，请求上下文中才会存在 `aws:PrincipalTag/job-category` 键。对于主体，如果使用附加了标签或会话标签的 IAM 角色，则也会包括它。如果没有标签的用户尝试查看或编辑访问键，则该条件返回 `false`，并且此语句将隐式拒绝请求。  
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  | <pre>aws:PrincipalTag/job-category:<br />  – iamuser-admin</pre>  |  匹配 | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  | <pre>aws:PrincipalTag/job-category:<br />  – dev-ops</pre>  | 不匹配 | 
|  <pre>"StringEquals": {<br />  "aws:PrincipalTag/job-category": "iamuser-admin"<br />}</pre>  |  请求上下文中没有 `aws:PrincipalTag/job-category`。  | 不匹配 | 

**Example 使用带有字符串运算符的策略变量**  
以下示例使用 `StringLike` 条件运算符执行与[策略变量](reference_policies_variables.md)的字符串匹配来创建策略，该策略允许 IAM 用户使用 Amazon S3 控制台管理其 Amazon S3 存储桶中的“主目录”。该策略允许对 S3 存储桶执行指定操作，前提是 `s3:prefix` 与任一指定模式相匹配。    
****  

```
{
  "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}/*"
      ]
    }
  ]
}
```
下表显示了 AWS 如何根据请求上下文中的 [aws:username](reference_policies_condition-keys.md#condition-keys-username) 值，并针对不同用户评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  | <pre>aws:username:<br />  – martha_rivera</pre>  | <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/martha_rivera/"<br />  ]<br />}</pre>  | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  |  <pre>aws:username:<br />  – nikki_wolf</pre>  |  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/nikki_wolf/"<br />  ]<br />}</pre>  | 
|  <pre>"StringLike": {<br />  "s3:prefix": [<br />    "home/",<br />    "home/${aws:username}/"<br />  ]<br />}</pre>  |  请求上下文中没有 `aws:username`。  | 不匹配 | 
有关说明如何使用 `Condition` 元素基于应用程序 ID 和用户 ID 限制资源的访问权限，以用于 OIDC 联合身份验证的策略示例，请参阅 [Amazon S3：允许 Amazon Cognito 用户访问其存储桶中的对象](reference_policies_examples_s3_cognito-bucket.md)。

### 多值字符串条件运算符
<a name="conditions_string_multivalued"></a>

如果请求中的一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定字符串运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。


| 条件运算符 | 说明 | 
| --- | --- | 
|  `ForAllValues:StringEquals` `ForAllValues:StringEqualsIgnoreCase`  |  请求中条件键的所有值均须与策略中的至少一个值相匹配。  | 
|  `ForAnyValue:StringEquals` `ForAnyValue:StringEqualsIgnoreCase`  |  请求中至少有一个条件键值须与策略中的一个值相匹配。  | 
|  `ForAllValues:StringNotEquals` `ForAllValues:StringNotEqualsIgnoreCase`  |  否定匹配。 请求中任何上下文键值均无法与策略中的任何上下文键值相匹配。  | 
|  `ForAnyValue:StringNotEquals` `ForAnyValue:StringNotEqualsIgnoreCase`  |  否定匹配。 请求中至少有一个上下文键值不得与策略中的任何上下文键值相匹配。  | 
|  `ForAllValues:StringLike`  |  请求中条件键的所有值均须与策略中的至少一个值相匹配。  | 
|  `ForAnyValue:StringLike`  |  请求中至少有一个条件键值须与策略中的一个值相匹配。  | 
|  `ForAllValues:StringNotLike`  |  否定匹配。 请求中任何上下文键值均无法与策略中的任何上下文键值相匹配。  | 
|  `ForAnyValue:StringNotLike`  |  否定匹配。 请求中至少有一个上下文键值不得与策略中的任何上下文键值相匹配。  | 

**Example 使用带有字符串条件运算符的 `ForAnyValue`**  
此示例说明如何创建允许使用 Amazon EC2 `CreateTags` 操作将标签附加到实例的基于身份的策略。在使用 `StringEqualsIgnoreCase` 的情况下，只有在标签包含值为 `preprod` 或 `storage` 的 `environment` 键时，才能附加标签。向运算符追加 `IgnoreCase` 时，允许任何现有标签值的大写（例如 `preprod`、`Preprod` 和 `PreProd`）解析为 true。  
当添加带有 [aws:TagKeys](reference_policies_condition-keys.md#condition-keys-tagkeys) 条件键的 `ForAnyValue` 修饰符时，请求中至少有一个标签键值须与 `environment` 值相匹配。`ForAnyValue` 比较区分大小写，这可以防止用户为标签键使用不正确的大小写，例如使用 `Environment` 而不是 `environment`。    
****  

```
{
  "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"
      }
    }
  }
}
```
 下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment<br />aws:RequestTag/environment:<br />  – preprod</pre>  | 匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment<br />  – costcenter<br />aws:RequestTag/environment:<br />  – PreProd</pre>  | 匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – Environment<br />aws:RequestTag/Environment:<br />  – preprod</pre>  | 不匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – costcenter<br />aws:RequestTag/environment:<br />  – preprod</pre>  | 不匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  |  请求上下文中没有 `aws:TagKeys`。 <pre>aws:RequestTag/environment:<br />  – storage</pre>  | 不匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  | <pre>aws:TagKeys:<br />  – environment</pre> 请求上下文中没有 `aws:RequestTag/environment`。  | 不匹配  | 
|  <pre>"StringEqualsIgnoreCase": {<br />  "aws:RequestTag/environment": [<br />    "preprod",<br />    "storage"<br />  ]<br />},<br />"ForAnyValue:StringEquals": {<br />  "aws:TagKeys": "environment"<br />}</pre>  |  请求上下文中没有 `aws:TagKeys`。 请求上下文中没有 `aws:RequestTag/environment`。  | 不匹配  | 

### 通配符匹配
<a name="Conditions_String-wildcard"></a>

字符串条件运算符执行不强制使用预定义格式的无模式匹配。ARN 和 Date 条件运算符是字符串运算符的子集，用于强制执行条件键值的结构。

我们建议您使用与要比较键的值对应的条件运算符。例如，在将键与字符串值进行比较时，应使用[字符串条件运算符](#Conditions_String)。同样，在将键与 ARN 值进行比较时，应使用 [Amazon Resource Name (ARN) 条件运算符](#Conditions_ARN)。

**Example**  
此示例演示了如何为组织的资源创建边界。该策略中的条件拒绝访问 Amazon S3 操作，除非当前访问的资源位于 AWS Organizations 中的特定组织单位 (OU) 中。AWS Organizations 路径是 Organizations 实体结构的文本表示形式。  
条件的要求是 `aws:ResourceOrgPaths` 包含列出的任何 OU 路径。由于 `aws:ResourceOrgPaths` 为多值条件，因此该策略使用 `ForAllValues:StringNotLike` 运算符来比较 `aws:ResourceOrgPaths` 的值和策略中的 OU 列表。    
****  

```
{
  "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/*"
          ] 
        }
      }
    }
  ]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  | <pre>aws:ResourceOrgPaths:<br />  – o-acorg/r-acroot/ou-acroot-sportsou/costcenter/</pre>  | 匹配 | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  | <pre>aws:ResourceOrgPaths:<br />  – o-acorg/r-acroot/ou-acroot-mediaou/costcenter/</pre>  | 不匹配 | 
|  <pre>"ForAllValues:StringNotLike": {<br />  "aws:ResourceOrgPaths": [<br />    "o-acorg/r-acroot/ou-acroot-mediaou/",<br />    "o-acorg/r-acroot/ou-acroot-sportsou/*"<br />  ] <br />}</pre>  |  请求中没有 `aws:ResourceOrgPaths:`。  | 不匹配 | 

## 数字条件运算符
<a name="Conditions_Numeric"></a>

利用数字条件运算符，您可以构建基于键与整数或小数值的对比来限制访问的 `Condition` 元素。
+  **策略变量** – 不支持
+ **通配符** - 不支持


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `NumericEquals`   |  Matching  | 
|   `NumericNotEquals`   |  否定匹配  | 
|   `NumericLessThan`   |  “小于”匹配  | 
|   `NumericLessThanEquals`   |  “小于或等于”匹配  | 
|   `NumericGreaterThan`   |  “大于”匹配  | 
|   `NumericGreaterThanEquals`   |  “大于或等于”匹配  | 

例如，以下语句包含一个 `Condition` 元素，该元素使用 `NumericLessThanEquals` 条件运算符与 `s3:max-keys` 密钥来指定请求者一次*最多*可在 `amzn-s3-demo-bucket` 内列出 10 个对象。

------
#### [ 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"}}
  }
}
```

------

如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。在此示例中，当您执行 `ListBucket` 操作时，`s3:max-keys` 键始终存在于请求中。如果此策略允许所有 Amazon S3 操作，则只允许包含值小于或等于 10 的 `max-keys` 上下文密钥的操作。

## 日期条件运算符
<a name="Conditions_Date"></a>

利用日期条件运算符，您可以构建基于键与日期/时间值的对比来限制访问的 `Condition` 元素。您可以将这些条件运算符与 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-currenttime) 键或 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-epochtime) 键配合使用。您必须指定日期/时间值，且其中一个 [W3C 实现要采用 ISO 8601 日期格式或新纪元 (UNIX) 时间格式](http://www.w3.org/TR/NOTE-datetime)。
+  **策略变量** – 不支持
+ **通配符** - 不支持


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `DateEquals`   |  匹配特定日期  | 
|   `DateNotEquals`   |  否定匹配  | 
|   `DateLessThan`   |  在特定日期和时间之前匹配。  | 
|   `DateLessThanEquals`   |  在特定日期和时间或之前匹配  | 
|   `DateGreaterThan`   |  在特定日期和时间之后匹配  | 
|   `DateGreaterThanEquals`   |  在特定日期和时间或之后匹配  | 

例如，以下语句包含一个 `Condition` 元素，该元素使用 `DateGreaterThan` 条件运算符与 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-tokenissuetime) 键。此条件指定用于发出请求的临时安全凭证在 2020 年签发。此策略可以通过编程方式每天更新，以确保账户成员使用最新的凭证。

------
#### [ 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"
            }
        }
    }
}
```

------

如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。只有在主体使用临时凭证发出请求时，才会在请求上下文中包含 `aws:TokenIssueTime` 键。使用访问密钥发出的 AWS CLI、AWS API 或 AWS 开发工具包请求中未提供此键。在此示例中，如果 IAM 用户尝试查看或编辑访问键，请求将被拒绝。

## 布尔值条件运算符
<a name="Conditions_Boolean"></a>

利用布尔值条件，您可以构建基于键与 `true` 或 `false` 的对比来限制访问的 `Condition` 元素。

如果一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定布尔运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。
+  **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - 不支持


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `Bool`   |  布尔值匹配  | 
|   `ForAllValues:Bool`   |  与布尔数组数据类型一起使用。上下文键值中所有布尔值均须与策略中的布尔值相匹配。 为防止 `ForAllValues` 运算符将缺失的上下文键或带有空值的上下文键评估为“允许”，可以在策略中包含 [Null 条件运算符](#Conditions_Null)。  | 
|   `ForAnyValue:Bool`   |  与布尔数组数据类型一起使用。上下文键值中至少有一个布尔值须与策略中的布尔值相匹配。  | 

**Example 布尔值条件运算符**  
以下基于身份的策略使用 `Bool` 条件运算符搭配 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-securetransport) 键拒绝将对象和对象标签复制到目标存储桶及其内容（如果请求不是通过 SSL 进行的）。  
该策略不允许进行任何操作。可将此策略与允许特定操作的其他策略结合使用。  
****  

```
{
  "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"
        }
      }
    }
  ]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  | <pre>aws:SecureTransport:<br />  – false</pre>  | 匹配 | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  | <pre>aws:SecureTransport:<br />  – true</pre>  | 不匹配 | 
|  <pre>"Bool": {<br />  "aws:SecureTransport": "false"<br />}</pre>  |  请求上下文中没有 `aws:SecureTransport`。  | 不匹配 | 

## 二进制条件运算符
<a name="Conditions_BinaryEquals"></a>

利用 `BinaryEquals` 条件运算符，您可以构建测试二进制格式键值的 `Condition` 元素。它会比较指定密钥字节的值和策略中 [base-64](https://en.wikipedia.org/wiki/Base64) 编码表示的二进制值。如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。
+  **策略变量** – 不支持
+ **通配符** - 不支持

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


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  | <pre>key:<br />  – QmluYXJ5VmFsdWVJbkJhc2U2NA==</pre>  | 匹配 | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  | <pre>key:<br />  – ASIAIOSFODNN7EXAMPLE</pre>  | 不匹配 | 
|  <pre>"BinaryEquals": {<br />  "key" : "QmluYXJ5VmFsdWVJbkJhc2U2NA=="<br />}</pre>  |  请求上下文中没有 `key`。  | 不匹配 | 

## IP 地址条件运算符
<a name="Conditions_IPAddress"></a>

利用 IP 地址条件运算符，您可以构建 `Condition` 元素，它们会基于键与 IPv4 或 IPv6 地址或 IP 地址范围的对比来限制访问。可以通过 [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceip) 键来使用它们。该值必须采用标准的 CIDR 格式 (例如 203.0.113.0/24 或 2001:DB8:1234:5678::/64)。如果您指定的 IP 地址没有关联的路由前缀，IAM 将使用 `/32` 作为默认前缀值。

某些 AWS 服务支持 IPv6，使用 :: 表示一系列 0。要了解某项服务是否支持 IPv6，请参阅该服务的文档。
+  **策略变量** – 不支持
+ **通配符** - 不支持


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `IpAddress`   |  指定的 IP 地址或范围  | 
|   `NotIpAddress`   |  除指定 IP 地址或范围外的所有 IP 地址  | 

**Example IP 地址条件运算符**  
下列语句使用 `IpAddress` 条件运算符与 `aws:SourceIp` 键来指定必须从 IP 范围 203.0.113.0 至 203.0.113.255 发出请求。    
****  

```
{
    "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"
            }
        }
    }
}
```
`aws:SourceIp` 条件键解析为发出请求的 IP 地址。如果请求源自 Amazon EC2 实例，则 `aws:SourceIp` 计算为实例的公有 IP 地址。  
如果请求上下文中没有您在策略条件中指定的键，则这些值不匹配。`aws:SourceIp` 键始终存在于请求上下文中，但请求者使用 VPC 终端节点发出请求时除外。在这种情况下，条件返回 `false`，并且此语句隐式拒绝请求。  
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"IpAddress": {<br />  "aws:SourceIp": "203.0.113.0/24"<br />}</pre>  | <pre>aws:SourceIp:<br />  – 203.0.113.1</pre>  | 匹配 | 
|  <pre>"IpAddress": {<br />  "aws:SourceIp": "203.0.113.0/24"<br />}</pre>  | <pre>aws:SourceIp:<br />  – 198.51.100.1</pre>  | 不匹配 | 
下面的示例说明如何结合使用 IPv4 和 IPv6 地址来覆盖组织的所有有效 IP 地址。建议您使用您的 IPv6 地址范围以及已拥有的 IPv4 范围来更新组织的策略，以确保策略在您过渡到 IPv6 时继续有效。    
****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": {
    "Effect": "Allow",
    "Action": "someservice:*",
    "Resource": "*",
    "Condition": {
      "IpAddress": {
        "aws:SourceIp": [
          "203.0.113.0/24",
          "2001:DB8:1234:5678::/64"
        ]
      }
    }
  }
}
```
如果以用户身份直接调用测试的 API，`aws:SourceIp` 条件键仅在 JSON 策略中有效。如果改为使用服务代表您调用目标服务，则目标服务看到的是进行调用的服务的 IP 地址而不是源用户的 IP 地址。举例来说，如果使用 AWS CloudFormation 调用 Amazon EC2 来构建实例，则会发生这种情况。目前，无法通过进行调用的服务将源 IP 地址传递给目标服务以在 JSON 策略中进行评估。对于这些服务 API 调用类型，请勿使用 `aws:SourceIp` 条件键。

## Amazon Resource Name (ARN) 条件运算符
<a name="Conditions_ARN"></a>

利用 Amazon Resource Name (ARN) 条件运算符，您可以构建基于键与 ARN 的对比来限制访问的 `Condition` 元素。ARN 被视为一个字符串。
+  **策略变量** - [支持](reference_policies_variables.md)
+ **通配符** - [支持](reference_policies_elements_resource.md#reference_policies_elements_resource_wildcards)


****  

| 条件运算符 | 说明 | 
| --- | --- | 
|   `ArnEquals`, `ArnLike`  |  区分大小写的 ARN 匹配。ARN 的六个由冒号分隔开的部分都要单独检查，每一个部分都可包括一个多字符匹配通配符（\$1）或一个单字符匹配通配符（?）。`ArnEquals` 和 `ArnLike` 条件运算符的行为相同。  | 
|   `ArnNotEquals`, `ArnNotLike`  |  ARN 无效匹配。`ArnNotEquals` 和 `ArnNotLike` 条件运算符的行为相同。  | 

**Example ARN 条件运算符**  
以下基于资源的策略示例显示附加到 Amazon SQS 队列（您希望向其发送 SNS 消息的队列）的策略。它授予 Amazon SNS 将消息发送到所选队列的权限，但仅在该服务代表特定 Amazon SNS 主题发送这些消息时才授予此权限。您在 `Resource` 字段中指定队列，Amazon SNS 主题则作为 `SourceArn` 密钥的值。    
****  

```
{
    "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"
            }
        }
    }
}
```
仅在资源触发一项服务以代表资源拥有者调用另一项服务时，[https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn) 键存在于请求上下文中。如果 IAM 用户尝试直接执行此操作，则条件返回 `false`，并且此语句隐式拒绝请求。  
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  | <pre>aws:SourceArn:<br />  – arn:aws:sns:us-west-2:123456789012:TOPIC-ID</pre>  | 匹配 | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  | <pre>aws:SourceArn:<br />  – arn:aws:sns:us-west-2:777788889999:TOPIC-ID</pre>  | 不匹配 | 
|  <pre>"ArnEquals": {<br />  "aws:SourceArn": "arn:aws:sns:us-west-2:123456789012:TOPIC-ID"<br />}</pre>  |  请求上下文中没有 `aws:SourceArn`。  | 不匹配 | 

### 多值 ARN 条件运算符
<a name="conditions_arn_multivalued"></a>

如果请求中的一个键包含多个值，则可以用集合运算符（`ForAllValues` 和 `ForAnyValue`）来限定 ARN 运算符。有关多个上下文键或值的评估逻辑的更多信息，请参阅 [多值上下文键的集合运算符](reference_policies_condition-single-vs-multi-valued-context-keys.md#reference_policies_condition-multi-valued-context-keys)。


| 条件运算符 | 说明 | 
| --- | --- | 
|  `ForAllValues:ArnEquals` `ForAllValues:ArnLike`  |  请求上下文中所有 ARN 均须与策略中的至少一个 ARN 模式相匹配。  | 
|  `ForAnyValue:ArnEquals` `ForAnyValue:ArnLike`  |  请求上下文中至少有一个 ARN 须与策略中的一个 ARN 模式相匹配。  | 
|  `ForAllValues:ArnNotEquals` `ForAllValues:ArnNotLike`  |  否定匹配。 请求上下文中任何 ARN 都无法与策略中的任何字符串 ARN 模式匹配。  | 
|  `ForAnyValue:ArnNotEquals` `ForAnyValue:ArnNotLike`  |  否定匹配。 请求上下文中至少有一个 ARN 不得与策略中的任何 ARN 模式相匹配。  | 

**Example 使用带有 ARN 条件运算符的 `ForAllValues`**  
以下示例使用 `ForAllValues:ArnLike` 创建或更新 Amazon CloudWatch Logs 日志的逻辑传输源。条件块中包含条件键 [https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazoncloudwatchlogs.html#amazoncloudwatchlogs-policy-keys)，可筛选请求中传递的日志生成资源 ARN。使用此条件运算符，请求中的所有 ARN 均须与策略中的至少一个 ARN 相匹配。    
****  

```
{
    "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*"
                    ]
                }
            }
        }
    ]
}
```
下表显示了 AWS 如何根据请求中的条件键值来评估此策略。  


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter</pre>  | 匹配 | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter<br />  – arn:aws::cloudfront:123456789012:distribution/support2025</pre>  | 匹配 | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:123456789012:distribution/costcenter<br />  – arn:aws::cloudfront:123456789012:distribution/admin</pre>  | 不匹配 | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  | <pre>logs:LogGeneratingResourceArns:<br />  – arn:aws::cloudfront:777788889999:distribution/costcenter</pre>  | 不匹配 | 
|  <pre>"ForAllValues:ArnLike": {<br />  "logs:LogGeneratingResourceArns": [<br />    "arn:aws::cloudfront:123456789012:distribution/*",<br />    "arn:aws::cloudfront:123456789012:distribution/support*"<br />  ]<br />}</pre>  |  请求上下文中没有 `logs:LogGeneratingResourceArns`。  | 匹配  | 
如果请求中没有上下文键或者上下文键值解析为空数据集（如空字符串），则 `ForAllValues` 限定符也会返回 true。为了防止缺失的上下文键或具有空值的上下文键评估为 true，您可以在策略中包含具有 `false` 值的 [Null 条件运算符](#Conditions_Null)，以检查上下文键是否存在且其值不为空。

## ...IfExists 条件运算符
<a name="Conditions_IfExists"></a>

除 `Null` 条件外，您可在任何条件运算符名称的末尾添加 `IfExists`，例如，`StringLikeIfExists`。如果您是指“如果请求的内容中存在条件键，则依照策略所述来处理键。如果该键不存在，则条件元素的计算结果将为 true。” 语句中其他条件因素仍然可以导致不匹配，但使用 `...IfExists` 检查时没有缺失键。如果您使用带有否定条件运算符（如 `StringNotEqualsIfExists`）的 `"Effect": "Deny"` 元素，则即使条件键不存在，请求仍会被拒绝。

**使用 `IfExists` 的示例**

许多条件键描述有关特定类型的资源的信息，仅当访问该类型的资源时才存在。这些条件键在其他类型的资源上不存在。当策略语句仅适用于一种类型的资源时，这不会导致问题。但是，有时单个语句可以适用于多种类型的资源，例如当策略语句从多个服务引用操作时，或是当服务中的给定操作访问同一服务中的多种不同资源类型时。在这种情况下，在策略语句中包含仅适用于一种资源的条件键可能会导致策略语句中的 `Condition` 元素失败，从而使语句的 `"Effect"` 不适用。

例如，请考虑以下策略示例：

------
#### [ JSON ]

****  

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

------

上述策略的*意图*是使用户能够启动类型为 `t1`、`t2` 或 `m3` 的任何实例。但是，启动实例要求访问除了实例本身之外的许多资源；例如映像、密钥对、安全组等。会针对启动实例所需的每个资源来评估整个语句。这些其他资源没有 `ec2:InstanceType` 条件键，因此 `StringLike` 检查会失败，并且不会向用户授予启动*任何* 实例类型的能力。

要解决此问题，请改用 `StringLikeIfExists` 条件运算符。这样，仅当条件键存在时才会进行测试。您会读到以下策略内容：If the resource being checked has an "`ec2:InstanceType`" condition key, then allow the action only if the key value begins with `t1.`, `t2.`, or `m3.`. 如果所检查的资源没有改条件键，则无需担心。” 条件键值中的星号 (\$1) 与 `StringLikeIfExists` 条件运算符一起使用时，会被解释为通配符以实现部分字符串匹配。`DescribeActions` 语句包含在控制台中查看实例所需的操作。

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

------

下表显示了 AWS 如何根据请求中的条件键值来评估此策略。


| 策略条件 | 请求上下文 | 结果 | 
| --- | --- | --- | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  | <pre>ec2:InstanceType:<br />  – t1.micro</pre>  | 匹配 | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  | <pre>ec2:InstanceType:<br />  – m2.micro</pre>  | 不匹配 | 
|  <pre>"StringLikeIfExists": {<br />  "ec2:InstanceType": [<br />    "t1.*",<br />    "t2.*",<br />    "m3.*"<br />  ]<br />}</pre>  |  请求上下文中没有 `ec2:InstanceType`。  | 匹配 | 

## 用于检查条件键是否存在的条件运算符
<a name="Conditions_Null"></a>

使用 `Null` 条件运算符检查授权时是否缺少条件键。在策略语句中使用 `true`（密钥不存在 - 为 null）或 `false`（密钥存在且值不为 null）。

您不能对[策略变量](reference_policies_variables.md)使用 `Null` 条件运算符。

例如，您可以使用此条件运算符来确定用户是使用临时凭证还是自己的凭证发出请求。如果用户使用的是临时凭证，则键 `aws:TokenIssueTime` 存在并具有一个值。以下示例显示了一个条件，该条件规定用户必须使用临时凭证（键不能缺失）才能使用 Amazon EC2 API。

------
#### [ JSON ]

****  

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

------