As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# AWS KMS chaves de condição
AWS KMS fornece um conjunto de chaves de condição que você pode usar em políticas de chaves e políticas do IAM. Essas chaves de condição são específicas para AWS KMS. Por exemplo, é possível usar a chave de condição `kms:EncryptionContext:context-key` para exigir um [contexto de criptografia](encrypt_context.md) específico ao controlar o acesso a uma chave do KMS de criptografia simétrica.
**Condições para uma solicitação de operação de API**
Muitas chaves de AWS KMS condição controlam o acesso a uma chave KMS com base no valor de um parâmetro na solicitação de uma AWS KMS operação. Por exemplo, você pode usar a chave de KeySpec condição [kms:](#conditions-kms-key-spec) em uma política do IAM para permitir o uso da [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação somente quando o valor do `KeySpec` parâmetro na `CreateKey` solicitação for`RSA_4096`.
Esse tipo de condição funciona mesmo quando o parâmetro não aparece na solicitação, como quando você usa o valor padrão do parâmetro. Por exemplo, é possível usar a chave de condição [kms:KeySpec](#conditions-kms-key-spec) para permitir que os usuários usem a operação `CreateKey` somente quando o valor do parâmetro `KeySpec` é `SYMMETRIC_DEFAULT`, que é o valor padrão. Essa condição permite solicitações que têm o parâmetro `KeySpec` com o valor `SYMMETRIC_DEFAULT` e solicitações que não têm parâmetro `KeySpec`.
**Condições para chaves do KMS usadas em operações de API**
Algumas chaves de AWS KMS condição podem controlar o acesso às operações com base em uma propriedade da chave KMS usada na operação. Por exemplo, você pode usar a KeyOrigin condição [kms:](#conditions-kms-key-origin) para permitir que os diretores [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)chamem uma chave KMS somente quando a `Origin` chave KMS for. `AWS_KMS` Para descobrir se uma chave de condição pode ser usada dessa maneira, consulte a descrição da chave de condição.
A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação. Se você usar esse tipo de chave de condição com uma operação não autorizada para um determinado recurso de chave KMS, por exemplo [ListKeys](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListKeys.html), a permissão não será efetiva porque a condição nunca poderá ser satisfeita. Não há recursos da chave do KMS envolvidos na autorização da operação `ListKeys` e nenhuma propriedade `KeySpec`.
Os tópicos a seguir descrevem cada chave de AWS KMS condição e incluem exemplos de declarações de política que demonstram a sintaxe da política.
**Usar operadores de conjuntos com chaves de condição**
Quando uma condição de política compara dois conjuntos de valores, como o conjunto de tags em uma solicitação e o conjunto de tags em uma política, você precisa saber AWS como comparar os conjuntos. O IAM define dois operadores de conjunto, `ForAnyValue` e `ForAllValues`, para essa finalidade. Use operadores de conjunto somente com *chaves de condição de vários valores*, que exigem esses operadores. Não use operadores de conjuntos com *chaves de condição de valor único*. Como sempre, teste suas instruções de política completamente antes de usá-las em um ambiente de produção.
Chaves de condição são de valor único ou de vários valores. Para determinar se uma chave de AWS KMS condição tem valor único ou de vários valores, consulte a coluna **Tipo de valor** na descrição da chave de condição.
+ Chaves de condição de *valor único* têm no máximo um valor no contexto de autorização (a solicitação ou o recurso). Por exemplo, como cada chamada de API pode ser originada de apenas uma Conta da AWS, [kms: CallerAccount](#conditions-kms-caller-account) é uma chave de condição de valor único. Não use um operador de conjunto com uma chave de condição de valor único.
+ Chaves de condição de *vários valores* têm diversos valores no contexto de autorização (a solicitação ou o recurso). Por exemplo, como cada chave KMS pode ter vários aliases, [kms: ResourceAliases](#conditions-kms-resource-aliases) pode ter vários valores. Chaves de condição de vários valores exigem um operador de conjunto.
Observe que a diferença entre chaves de condição de valor único e de vários valores depende do número de valores no contexto de autorização, e não do número de valores na condição da política.
**Atenção**
O uso de um operador de conjunto com uma chave de condição de valor único pode criar uma instrução de política excessivamente permissiva (ou excessivamente restritiva). Use operadores de conjunto somente com chaves de condição de vários valores.
Se você criar ou atualizar uma política que inclua um operador de `ForAllValues` conjunto com kms:EncryptionContext: *chave de contexto* ou chaves de `aws:RequestTag/tag-key` condição, AWS KMS retornará a seguinte mensagem de erro:
`OverlyPermissiveCondition: Using the ForAllValues set operator with a single-valued condition key matches requests without the specified [encryption context or tag] or with an unspecified [encryption context or tag]. To fix, remove ForAllValues.`
Para obter informações detalhadas sobre os operadores de conjunto `ForAnyValue` e `ForAllValues`, consulte [Usar várias chaves e valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multi-key-or-value-conditions), no *Manual do usuário do IAM*. Para obter informações sobre o risco de usar o operador `ForAllValues` set com uma condição de valor único, consulte [Aviso de segurança — ForAllValues com chave de valor único](https://docs.aws.amazon.com/IAM/latest/UserGuide/access-analyzer-reference-policy-checks.html#access-analyzer-reference-policy-checks-security-warning-forallvalues-with-single-valued-key) no *Guia do usuário do IAM*.
**Topics**
+ [kms:BypassPolicyLockoutSafetyCheck](#conditions-kms-bypass-policy-lockout-safety-check)
+ [kms:CallerAccount](#conditions-kms-caller-account)
+ [kms: CustomerMasterKeySpec (obsoleto)](#conditions-kms-key-spec-replaced)
+ [kms: CustomerMasterKeyUsage (obsoleto)](#conditions-kms-key-usage-replaced)
+ [kms:DataKeyPairSpec](#conditions-kms-data-key-spec)
+ [kms:EncryptionAlgorithm](#conditions-kms-encryption-algorithm)
+ [*kms:EncryptionContext: chave de contexto*](#conditions-kms-encryption-context)
+ [kms:EncryptionContextKeys](#conditions-kms-encryption-context-keys)
+ [kms:ExpirationModel](#conditions-kms-expiration-model)
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
+ [kms:GrantIsForAWSResource](#conditions-kms-grant-is-for-aws-resource)
+ [kms:GrantOperations](#conditions-kms-grant-operations)
+ [kms:GranteePrincipal](#conditions-kms-grantee-principal)
+ [kms:KeyAgreementAlgorithm](#conditions-kms-key-agreement-algorithm)
+ [kms:KeyOrigin](#conditions-kms-key-origin)
+ [kms:KeySpec](#conditions-kms-key-spec)
+ [kms:KeyUsage](#conditions-kms-key-usage)
+ [kms:MacAlgorithm](#conditions-kms-mac-algorithm)
+ [kms:MessageType](#conditions-kms-message-type)
+ [kms:MultiRegion](#conditions-kms-multiregion)
+ [kms:MultiRegionKeyType](#conditions-kms-multiregion-key-type)
+ [kms:PrimaryRegion](#conditions-kms-primary-region)
+ [kms:ReEncryptOnSameKey](#conditions-kms-reencrypt-on-same-key)
+ [kms:RequestAlias](#conditions-kms-request-alias)
+ [kms:ResourceAliases](#conditions-kms-resource-aliases)
+ [kms:ReplicaRegion](#conditions-kms-replica-region)
+ [kms:RetiringPrincipal](#conditions-kms-retiring-principal)
+ [kms:RotationPeriodInDays](#conditions-kms-rotation-period-in-days)
+ [kms:ScheduleKeyDeletionPendingWindowInDays](#conditions-kms-schedule-key-deletion-pending-window-in-days)
+ [kms:SigningAlgorithm](#conditions-kms-signing-algorithm)
+ [kms:ValidTo](#conditions-kms-valid-to)
+ [kms:ViaService](#conditions-kms-via-service)
+ [kms:WrappingAlgorithm](#conditions-kms-wrapping-algorithm)
+ [kms:WrappingKeySpec](#conditions-kms-wrapping-key-spec)
## kms:BypassPolicyLockoutSafetyCheck
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:BypassPolicyLockoutSafetyCheck` | Booleano | Valor único | `CreateKey` `PutKeyPolicy` | Somente políticas do IAM Políticas de chaves e políticas do IAM |
A chave de `kms:BypassPolicyLockoutSafetyCheck` condição controla o acesso às [PutKeyPolicy](https://docs.aws.amazon.com/kms/latest/APIReference/API_PutKeyPolicy.html)operações [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)e com base no valor do `BypassPolicyLockoutSafetyCheck` parâmetro na solicitação.
A instrução de política do IAM de exemplo a seguir impede que os usuários ignorem a verificação de segurança de bloqueio da política ao negar a eles a permissão para criar chaves do KMS quando o valor do parâmetro `BypassPolicyLockoutSafetyCheck` na solicitação `CreateKey` é `true.`
```
{
"Effect": "Deny",
"Action": [
"kms:CreateKey",
"kms:PutKeyPolicy"
],
"Resource": "*",
"Condition": {
"Bool": {
"kms:BypassPolicyLockoutSafetyCheck": true
}
}
}
```
Você também pode usar a chave de condição `kms:BypassPolicyLockoutSafetyCheck` em uma política do IAM ou política de chaves para controlar o acesso à operação `PutKeyPolicy`. A declaração de política de exemplo a seguir de uma política de chaves impede que os usuários ignorem a verificação de segurança de bloqueio da política ao alterar a política de uma chave do KMS.
Em vez de usar `Deny` de forma explícita, esta declaração de política usa `Allow` com o [operador de condição nula](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Null) para permitir o acesso somente quando a solicitação não inclui o parâmetro `BypassPolicyLockoutSafetyCheck`. Quando o parâmetro não for usado, o valor padrão será `false`. Essa instrução de política um pouco mais fraca pode ser substituída no caso raro em que uma derivação é necessária.
```
{
"Effect": "Allow",
"Action": "kms:PutKeyPolicy",
"Resource": "*",
"Condition": {
"Null": {
"kms:BypassPolicyLockoutSafetyCheck": true
}
}
}
```
**Consulte também**
+ [kms:KeySpec](#conditions-kms-key-spec)
+ [kms:KeyOrigin](#conditions-kms-key-origin)
+ [kms:KeyUsage](#conditions-kms-key-usage)
## kms:CallerAccount
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:CallerAccount` | String | Valor único | Operações de recursos de chaves do KMS Operações do armazenamento de chaves personalizado | Políticas de chaves e políticas do IAM |
É possível usar essa chave de condição para permitir ou negar acesso a todas as identidades (usuários e perfis) em uma Conta da AWS. Em políticas de chaves, você pode usar o elemento `Principal` para especificar as identidades às quais a declaração de política se aplica. A sintaxe do elemento `Principal` não fornece uma forma de especificar todas as identidades em uma Conta da AWS. Mas você pode obter esse efeito combinando essa chave de condição com um `Principal` elemento que especifica todas as AWS identidades.
Você pode usá-lo para controlar o acesso a qualquer *operação de recurso de chave KMS*, ou seja, qualquer AWS KMS operação que use uma chave KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação. Ele também é válido para operações que gerenciam [armazenamentos de chaves personalizados](key-store-overview.md#custom-key-store-overview).
Por exemplo, a instrução de política de chaves a seguir demonstra como usar a chave de condição `kms:CallerAccount`. Esta declaração de política está na política principal do Chave gerenciada pela AWS Amazon EBS. Ele combina um `Principal` elemento que especifica todas as AWS identidades com a chave de `kms:CallerAccount` condição para permitir efetivamente o acesso a todas as identidades em 111122223333. Conta da AWS Ele contém uma chave de AWS KMS condição adicional (`kms:ViaService`) para limitar ainda mais as permissões, permitindo somente solicitações provenientes do Amazon EBS. Para obter mais informações, consulte [kms:ViaService](#conditions-kms-via-service).
```
{
"Sid": "Allow access through EBS for all principals in the account that are authorized to use EBS",
"Effect": "Allow",
"Principal": {"AWS": "*"},
"Condition": {
"StringEquals": {
"kms:CallerAccount": "111122223333",
"kms:ViaService": "ec2.us-west-2.amazonaws.com"
}
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:CreateGrant",
"kms:DescribeKey"
],
"Resource": "*"
}
```
## kms: CustomerMasterKeySpec (obsoleto)
A chave de condição `kms:CustomerMasterKeySpec` está defasada. Em vez disso, use a chave de KeySpec condição [kms:](#conditions-kms-key-spec).
As chaves de condição `kms:CustomerMasterKeySpec` e `kms:KeySpec` funcionam da mesma forma. Apenas os nomes são diferentes. Recomendamos usar o `kms:KeySpec`. No entanto, para evitar alterações significativas, AWS KMS suporta as duas teclas de condição.
## kms: CustomerMasterKeyUsage (obsoleto)
A chave de condição `kms:CustomerMasterKeyUsage` está defasada. Em vez disso, use a chave de KeyUsage condição [kms:](#conditions-kms-key-usage).
As chaves de condição `kms:CustomerMasterKeyUsage` e `kms:KeyUsage` funcionam da mesma forma. Apenas os nomes são diferentes. Recomendamos usar o `kms:KeyUsage`. No entanto, para evitar alterações significativas, AWS KMS suporta as duas teclas de condição.
## kms:DataKeyPairSpec
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:DataKeyPairSpec` | String | Valor único | `GenerateDataKeyPair` `GenerateDataKeyPairWithoutPlaintext` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para controlar o acesso às [GenerateDataKeyPairWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPairWithoutPlaintext.html)operações [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html)e com base no valor do `KeyPairSpec` parâmetro na solicitação. Por exemplo, é possível permitir que os usuários gerem somente tipos de pares de chaves de dados específicos.
O exemplo de instrução de política de chaves a seguir usa a chave de condição `kms:DataKeyPairSpec` para permitir que os usuários usem a chave do KMS para gerar somente pares de chaves de dados RSA.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": [
"kms:GenerateDataKeyPair",
"kms:GenerateDataKeyPairWithoutPlaintext"
],
"Resource": "*",
"Condition": {
"StringLike": {
"kms:DataKeyPairSpec": "RSA*"
}
}
}
```
**Consulte também**
+ [kms:KeySpec](#conditions-kms-key-spec)
+ [kms:EncryptionAlgorithm](#conditions-kms-encryption-algorithm)
+ [*kms:EncryptionContext: chave de contexto*](#conditions-kms-encryption-context)
+ [kms:EncryptionContextKeys](#conditions-kms-encryption-context-keys)
## kms:EncryptionAlgorithm
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:EncryptionAlgorithm` | String | Valor único | `Decrypt` `Encrypt` `GenerateDataKey` `GenerateDataKeyPair` `GenerateDataKeyPairWithoutPlaintext` `GenerateDataKeyWithoutPlaintext` `ReEncrypt` | Políticas de chaves e políticas do IAM |
É possível usar a chave de condição `kms:EncryptionAlgorithm` para controlar o acesso às operações de criptografia com base no algoritmo de criptografia usado na operação. Para as [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)operações [Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html), [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) e, ele controla o acesso com base no valor do [EncryptionAlgorithm](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html#KMS-Decrypt-request-EncryptionAlgorithm)parâmetro na solicitação. Para operações que geram chaves de dados e pares de chaves de dados, ela controla o acesso com base no algoritmo de criptografia que é usado para criptografar a chave de dados.
Essa chave de condição não tem efeito nas operações realizadas fora da AWS KMS, como a criptografia com a chave pública em um par de chaves KMS assimétrico fora da. AWS KMS
**EncryptionAlgorithm parâmetro em uma solicitação**
Para permitir que os usuários usem apenas um algoritmo de criptografia específico com uma chave do KMS, use uma instrução de política com um efeito `Deny` e um operador de condição `StringNotEquals`. Por exemplo, o seguinte exemplo de instrução de política de chaves proíbe que as entidades principais capazes de assumir a função `ExampleRole` usem essa chave do KMS nas operações de criptografia especificadas, a menos que o algoritmo de criptografia na solicitação seja `RSAES_OAEP_SHA_256`, um algoritmo criptográfico assimétrico usado em chaves RSA do KMS.
Diferente de uma instrução de política que permite que um usuário utilize um algoritmo de criptografia específico, uma instrução de política com um duplo negativo como essa evita que outras políticas e concessões da chave do KMS permitam que essa função use outros algoritmos de criptografia. O `Deny` nessa instrução de política de chaves tem precedência sobre qualquer política de chaves ou política do IAM com um efeito `Allow` e tem precedência sobre todas as concessões dessa chave do KMS e suas entidades principais.
```
{
"Sid": "Allow only one encryption algorithm with this asymmetric KMS key",
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*"
],
"Resource": "*",
"Condition": {
"StringNotEquals": {
"kms:EncryptionAlgorithm": "RSAES_OAEP_SHA_256"
}
}
}
```
**Algoritmo de criptografia usado para a operação**
Você também pode usar a chave de condição `kms:EncryptionAlgorithm` para controlar o acesso às operações com base no algoritmo de criptografia utilizado na operação, mesmo quando esse algoritmo não está especificado na solicitação. Isso permite exigir ou proibir o algoritmo `SYMMETRIC_DEFAULT`, que pode não ser especificado em uma solicitação por ser o valor padrão.
Também é possível usar a chave de condição `kms:EncryptionAlgorithm` para controlar o acesso às operações que geram chaves de dados e pares de chaves de dados. Essas operações só usam chaves do KMS de criptografia simétrica e o algoritmo `SYMMETRIC_DEFAULT`.
Por exemplo, essa política do IAM limita seus principais à criptografia simétrica. Ela nega o acesso a qualquer chave do KMS na conta de exemplo para operações de criptografia, a menos que o algoritmo de criptografia especificado na solicitação ou usado na operação seja SYMMETRIC\$1DEFAULT. Incluindo `GenerateDataKey*` [GenerateDataKeyPair](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPair.html)acréscimos [GenerateDataKey[GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html)](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html),, e [GenerateDataKeyPairWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyPairWithoutPlaintext.html)às permissões. A condição não tem efeito nessas operações porque elas sempre utilizam um algoritmo de criptografia simétrica.
```
{
"Sid": "AllowOnlySymmetricAlgorithm",
"Effect": "Deny",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*"
],
"Resource": "arn:aws:kms:us-west-2:111122223333:key/*",
"Condition": {
"StringNotEquals": {
"kms:EncryptionAlgorithm": "SYMMETRIC_DEFAULT"
}
}
}
```
**Consulte também**
+ [kms:MacAlgorithm](#conditions-kms-mac-algorithm)
+ [kms:SigningAlgorithm](#conditions-kms-signing-algorithm)
## *kms:EncryptionContext: chave de contexto*
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:EncryptionContext:context-key` | String | Valor único | `CreateGrant` `Encrypt` `Decrypt` `GenerateDataKey` `GenerateDataKeyPair` `GenerateDataKeyPairWithoutPlaintext` `GenerateDataKeyWithoutPlaintext` `ReEncrypt` `RetireGrant` | Políticas de chaves e políticas do IAM |
É possível usar a chave de condição `kms:EncryptionContext:context-key` para controlar o acesso a uma [chave do KMS de criptografia simétrica](symm-asymm-choose-key-spec.md#symmetric-cmks) com base no [contexto de criptografia](encrypt_context.md) em uma solicitação de uma [operação criptográfica](kms-cryptography.md#cryptographic-operations). Use essa chave de condição para avaliar a chave e o valor no par de contexto de criptografia. Para avaliar somente as chaves do contexto de criptografia ou exigir um contexto de criptografia, independentemente das chaves ou dos valores, use a chave de EncryptionContextKeys condição [kms:](#conditions-kms-encryption-context-keys).
**nota**
Os valores das chaves de condição devem estar em conformidade com as regras de caracteres para políticas de chaves e políticas do IAM. Alguns caracteres que são válidos em um contexto de criptografia não são válidos em políticas. Talvez você não consiga usar essa chave de condição para expressar todos os valores válidos de contexto de criptografia. Para obter detalhes sobre as regras de documento de política de chaves, consulte [Formato de política de chaves](key-policy-overview.md#key-policy-format). Para obter detalhes sobre as regras de documento de política do IAM, consulte [Requisitos de nome do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-names) no *Guia do usuário do IAM*.
Não é possível especificar um contexto de criptografia em uma operação criptográfica com uma [chave do KMS assimétrica](symmetric-asymmetric.md) ou uma [chave do KMS de Hash-based message authentication code (HMAC – Código de autenticação de mensagem por hash)](hmac.md). Algoritmos assimétricos e algoritmos de Message authentication code (MAC – Código de autenticação de mensagem) não são compatíveis com um contexto de criptografia.
Para usar a chave de condição kms:EncryptionContext: *chave de contexto*, substitua o *context-key* espaço reservado pela chave de contexto de criptografia. Substitua o espaço reservado *context-value* pelo valor de contexto de criptografia.
```
"kms:EncryptionContext:context-key": "context-value"
```
Por exemplo, a seguinte chave de condição especifica um contexto de criptografia no qual a chave é `AppName` e o valor é `ExampleApp` (`AppName = ExampleApp`).
```
"kms:EncryptionContext:AppName": "ExampleApp"
```
Esta é uma [chave de condição de valor único](#set-operators). A chave na chave de condição especifica uma chave de contexto de criptografia específica (*context-key*). Embora seja possível incluir vários pares de contexto de criptografia em cada solicitação de API, o par de contexto de criptografia com a *context-key* especificada pode ter somente um valor. Por exemplo, a chave de condição `kms:EncryptionContext:Department` aplica-se somente a pares de contexto de criptografia com uma chave `Department`, e qualquer par de contexto de criptografia com a chave `Department` pode ter somente um valor.
Não use um operador de conjunto com a chave de condição `kms:EncryptionContext:context-key`. Se você criar uma instrução de política com uma ação `Allow`, a chave de condição `kms:EncryptionContext:context-key` e o operador de conjunto `ForAllValues`, a condição permitirá solicitações sem contexto de criptografia e solicitações com pares de contexto de criptografia que não estão especificados na condição de política.
**Atenção**
Não use um operador de conjunto `ForAnyValue` ou `ForAllValues` com essa chave de condição de valor único. Esses operadores de conjunto podem criar uma condição de política que não requer valores que você pretende exigir e permite valores que você pretende proibir.
Se você criar ou atualizar uma política que inclua um operador de `ForAllValues` conjunto com a *chave de contexto kms: EncryptionContext*:, AWS KMS retornará a seguinte mensagem de erro:
`OverlyPermissiveCondition:EncryptionContext: Using the ForAllValues set operator with a single-valued condition key matches requests without the specified encryption context or with an unspecified encryption context. To fix, remove ForAllValues.`
Para exigir um par de contexto de criptografia específico, use a chave de condição `kms:EncryptionContext:context-key` com o operador `StringEquals`.
A seguinte instrução de política de chaves de exemplo permite que as entidades principais que podem assumir a função usem a chave do KMS em uma solicitação `GenerateDataKey` apenas quando o contexto de criptografia nessa solicitação inclui o par `AppName:ExampleApp`. Outros pares de contexto de criptografia são permitidos.
O nome da chave não é sensível a maiúsculas e minúsculas. A diferenciação de maiúsculas e minúsculas do valor é determinada pelo operador de condição, como `StringEquals`. Para obter detalhes, consulte [Diferenciação de letras maiúsculas e minúsculas da condição de contexto de criptografia](#conditions-kms-encryption-context-case).
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:AppName": "ExampleApp"
}
}
}
```
Para exigir um par de contexto de criptografia e proibir todos os outros pares de contexto de criptografia, use ambos kms:EncryptionContext: *chave de contexto* e [`kms:EncryptionContextKeys`](#conditions-kms-encryption-context-keys)na declaração de política. A instrução de política de exemplo a seguir usa a condição `kms:EncryptionContext:AppName` para exigir o par de contextos de criptografia `AppName=ExampleApp` na solicitação. Ela também usa uma chave de condição `kms:EncryptionContextKeys` com o operador de conjunto `ForAllValues` para permitir apenas a chave de contexto de criptografia `AppName`.
O operador de conjunto `ForAllValues` limita as chaves de contexto de criptografia na solicitação para `AppName`. Se a condição `kms:EncryptionContextKeys` com o operador de conjunto `ForAllValues` tivesse sido usada sozinha em uma instrução de política, esse operador de conjunto permitiria solicitações sem contexto de criptografia. No entanto, se a solicitação não tivesse um contexto de criptografia, a condição `kms:EncryptionContext:AppName` falharia. Para detalhes sobre o operador de conjunto `ForAllValues`, consulte[Usar várias chaves e valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multi-key-or-value-conditions), no *Manual do usuário do IAM*.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/KeyUsers"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:AppName": "ExampleApp"
},
"ForAllValues:StringEquals": {
"kms:EncryptionContextKeys": [
"AppName"
]
}
}
}
```
Também é possível usar essa chave de condição para negar acesso a uma chave do KMS para uma operação específica. O exemplo a seguir de instrução de política de chaves usa um efeito `Deny` para proibir a entidade principal de usar a chave do KMS quando o contexto de criptografia na solicitação inclui um par de contextos de criptografia `Stage=Restricted`. Essa condição permite uma solicitação com outros pares de contextos de criptografia, incluindo pares de contextos de criptografia com a chave `Stage` e outros valores, como `Stage=Test`.
```
{
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Stage": "Restricted"
}
}
}
```
### Usar vários pares de contextos de criptografia
Você pode exigir ou proibir vários pares de contextos de criptografia. Também pode exigir um dos vários pares de contextos de criptografia. Para obter detalhes sobre a lógica usada para interpretar essas condições, consulte [Criar uma condição com várias chaves ou valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html), no Manual do usuário do IAM.
**nota**
As versões anteriores deste tópico exibiam declarações de política que usavam os operadores `ForAnyValue` e `ForAllValues` definiam com a chave de condição kms:EncryptionContext: *chave de contexto*. Usar um operador de conjunto com uma [chave de condição de valor único](#set-operators) pode resultar em políticas que permitem solicitações sem contexto de criptografia e pares de contextos de criptografia não especificados.
Por exemplo, uma condição de política com o efeito `Allow`, o operador de conjunto `ForAllValues` e a chave de condição `"kms:EncryptionContext:Department": "IT"` não limita o contexto de criptografia ao par "Department=IT". Ele permite solicitações sem contexto de criptografia e solicitações com pares de contextos de criptografia não especificados, como `Stage=Restricted`.
Revise suas políticas e elimine o operador definido de qualquer condição com kms:EncryptionContext: *context-key*. Tentativas de criar ou atualizar uma política com esse formato falham com uma exceção `OverlyPermissiveCondition`. Para resolver o erro, exclua o operador de conjunto.
Para exigir vários pares de contextos de criptografia, liste esses pares na mesma condição. A seguinte instrução de política de chaves de exemplo requer dois pares de contextos de criptografia: `Department=IT` e `Project=Alpha`. Como as condições têm chaves diferentes (`kms:EncryptionContext:Department` e `kms:EncryptionContext:Project`), elas são implicitamente conectadas por um operador AND. Outros pares de contextos de criptografia são permitidos, mas não são necessários.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:Decrypt",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Department": "IT",
"kms:EncryptionContext:Project": "Alpha"
}
}
}
```
Para exigir um par de contextos de criptografia OU outro par, coloque cada chave de condição em uma instrução de política separada. O exemplo a seguir de política de chaves requer pares `Department=IT` *ou* `Project=Alpha`, ou ambos. Outros pares de contextos de criptografia são permitidos, mas não são necessários.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Department": "IT"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Project": "Alpha"
}
}
}
```
Para exigir pares de criptografia específicos e excluir todos os outros pares de contexto de criptografia, use kms:EncryptionContext: *chave de contexto* e [`kms:EncryptionContextKeys`](#conditions-kms-encryption-context-keys)na declaração de política. A seguinte declaração de política de chaves usa a condição kms:EncryptionContext: *context-key* para exigir um contexto de criptografia com pares `Department=IT` *e*`Project=Alpha`. Ela usa uma chave de condição `kms:EncryptionContextKeys` com o operador de conjunto `ForAllValues` para permitir apenas as chaves de contexto de criptografia `Department` e `Project`.
O operador de conjunto `ForAllValues` limita as chaves de contexto de criptografia na solicitação para `Department` e `Project`. Se fosse usado sozinho em uma condição, esse operador de conjunto permitiria solicitações sem contexto de criptografia, mas nessa configuração, a *chave de contexto kms: EncryptionContext*: nessa condição falharia.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Department": "IT",
"kms:EncryptionContext:Project": "Alpha"
},
"ForAllValues:StringEquals": {
"kms:EncryptionContextKeys": [
"Department",
"Project"
]
}
}
}
```
Você também pode proibir vários pares de contexto de criptografia. O seguinte exemplo de instrução de política de chaves usa um efeito `Deny` para proibir a entidade principal de usar as chaves do KMS se o contexto de criptografia na solicitação incluir um par `Stage=Restricted` ou `Stage=Production`.
Vários valores (`Restricted` e `Production`) para a mesma chave (`kms:EncryptionContext:Stage`) são implicitamente conectados por OR. Para obter mais detalhes, consulte [Lógica de avaliação para condições com várias chaves ou valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multiple-conditions-eval), no *Manual do usuário do IAM*.
```
{
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Stage": [
"Restricted",
"Production"
]
}
}
}
```
### Diferenciação de letras maiúsculas e minúsculas da condição de contexto de criptografia
O contexto de criptografia especificado em uma operação de criptografia deve ser uma correspondência exata, que diferencia maiúsculas de minúsculas para o contexto de criptografia especificado na operação de criptografia. Somente a ordem dos pares em um contexto de criptografia com vários pares pode variar.
No entanto, em condições de política, a chave de condição não diferencia maiúsculas de minúsculas. A diferenciação de maiúsculas e minúsculas do valor da condição é determinada pelo [operador de condição de política](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html) que você usa, como `StringEquals` ou `StringEqualsIgnoreCase`.
Dessa forma, a chave de condição, que consiste do prefixo `kms:EncryptionContext:` e da substituição *`context-key`*, não diferencia maiúsculas de minúsculas. Uma política que usa essa condição não verifica a capitalização dos elementos da chave de condição. A diferenciação de maiúsculas e minúsculas do valor, ou seja, a substituição *`context-value`*, é determinada pelo operador de condição de política.
Por exemplo, a declaração de política a seguir permite a operação quando o contexto de criptografia inclui uma chave `Appname`, independentemente da sua capitalização. A condição `StringEquals` exige que `ExampleApp` seja capitalizado da maneira como foi especificado.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:Decrypt",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:Appname": "ExampleApp"
}
}
}
```
Para exigir uma chave de contexto de criptografia com distinção entre maiúsculas e minúsculas, use a condição [kms: EncryptionContextKeys policy com um operador](#conditions-kms-encryption-context-keys) de condição que diferencia maiúsculas de minúsculas, como. `StringEquals` Nesta condição de política, como a chave de contexto de criptografia é o valor da condição de política, o recurso é determinado pelo operador da condição.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"kms:EncryptionContextKeys": "AppName"
}
}
}
```
Para exigir uma avaliação com distinção entre maiúsculas e minúsculas da chave de contexto e do valor da criptografia, use as condições de política de *chave de contexto `kms:EncryptionContextKeys`* e kms:EncryptionContext: juntas na mesma declaração de política. O operador de condição sensível a maiúsculas e minúsculas (como`StringEquals`) sempre aplica-se ao valor da condição. A chave de contexto de criptografia (como `AppName`) é o valor da condição `kms:EncryptionContextKeys`. O valor do contexto de criptografia (como`ExampleApp`) é o valor da condição kms:EncryptionContext: *context-key*.
Por exemplo, na instrução de política de chaves a seguir, como o operador `StringEquals` diferencia maiúsculas de minúsculas, a chave de contexto de criptografia e o valor de contexto de criptografia diferenciam maiúsculas de minúsculas.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"kms:EncryptionContextKeys": "AppName"
},
"StringEquals": {
"kms:EncryptionContext:AppName": "ExampleApp"
}
}
}
```
### Usar variáveis em uma condição de contexto de criptografia
A chave e o valor em um par de contexto de criptografia devem ser strings literais simples. Não podem ser números inteiros, objetos, ou qualquer tipo que não esteja totalmente resolvido. Se você usar um tipo diferente, como um número inteiro ou flutuante, AWS KMS interprete-o como uma string literal.
```
"encryptionContext": {
"department": "10103.0"
}
```
No entanto, o valor da chave de condição `kms:EncryptionContext:context-key` pode ser uma [variável de política do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html). Essas variáveis de política são resolvidas em runtime com base nos valores da solicitação. Por exemplo, o `aws:CurrentTime ` é resolvido como a hora da solicitação e `aws:username` é resolvido como o nome amigável do chamador.
É possível usar essas variáveis de política para criar uma declaração de política com uma condição que requer informações muito específicas em um contexto de criptografia, como o nome de usuário do chamador. Como contém uma variável, é possível usar a mesma declaração de política para todos os usuários que podem assumir a função. Não é necessário escrever uma declaração de política diferente para cada usuário.
Considere uma situação em que você deseja que todos os usuários que podem assumir uma função usem a mesma chave do KMS para criptografar e descriptografar seus dados. No entanto, você deseja permitir que eles descriptografem somente os dados que criptografaram. Comece exigindo que cada solicitação AWS KMS inclua um contexto de criptografia em que a chave esteja `user` e o valor seja o nome de AWS usuário do chamador, como o seguinte.
```
"encryptionContext": {
"user": "bob"
}
```
Para impor esse requisito, é possível usar uma declaração de política como a do exemplo a seguir. Essa instrução de política concede à função `TestTeam` permissão para criptografar e descriptografar dados com a chave do KMS. No entanto, a permissão será válida somente quando o contexto de criptografia na solicitação incluir um par `"user": ""`. Para representar o nome do usuário, a condição usa a variável de política [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#policy-vars-infotouse](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#policy-vars-infotouse).
Quando a solicitação for avaliada, o nome de usuário do chamador substituirá a variável na condição. Dessa forma, a condição requer um contexto de criptografia de `"user": "bob"` para "bob" e `"user": "alice"` para "alice".
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/TestTeam"
},
"Action": [
"kms:Decrypt",
"kms:Encrypt"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:user": "${aws:username}"
}
}
}
```
É possível usar uma variável de política do IAM somente no valor do par de chaves da condição `kms:EncryptionContext:context-key`. Não é possível usar uma variável na chave.
Também não é possível usar [chaves de contexto específicas do provedor](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc_user-id.html) em variáveis. Essas chaves de contexto identificam de forma exclusiva os usuários que se conectaram AWS usando a federação de identidade da web.
Como todas as variáveis, essas variáveis podem ser usadas apenas na condição de política `kms:EncryptionContext:context-key`, não no contexto de criptografia real. E elas podem ser usadas apenas no valor da condição, não na chave.
Por exemplo, a declaração de política de chaves a seguir é semelhante à anterior. No entanto, a condição requer um contexto de criptografia em que a chave é `sub` e o valor identifica exclusivamente um usuário conectado a um grupo de usuários do Amazon Cognito. Para obter detalhes sobre como identificar usuários e funções no Amazon Cognito, consulte [Funções do IAM](https://docs.aws.amazon.com/cognito/latest/developerguide/iam-roles.html), no [Guia do desenvolvedor do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/).
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/TestTeam"
},
"Action": [
"kms:Decrypt",
"kms:Encrypt"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:EncryptionContext:sub": "${cognito-identity.amazonaws.com:sub}"
}
}
}
```
**Consulte também**
+ [kms:EncryptionContextKeys](#conditions-kms-encryption-context-keys)
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
## kms:EncryptionContextKeys
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:EncryptionContextKeys` | String (lista) | Vários valores | `CreateGrant` `Decrypt` `Encrypt` `GenerateDataKey` `GenerateDataKeyPair` `GenerateDataKeyPairWithoutPlaintext` `GenerateDataKeyWithoutPlaintext` `ReEncrypt` `RetireGrant` | Políticas de chaves e políticas do IAM |
É possível usar a chave de condição `kms:EncryptionContextKeys` para controlar o acesso a uma [chave do KMS de criptografia simétrica](symm-asymm-choose-key-spec.md#symmetric-cmks) com base no [contexto de criptografia](encrypt_context.md) em uma solicitação de uma operação criptográfica. Use essa chave de condição para avaliar apenas a chave em cada par de contexto de criptografia. Para avaliar tanto a chave quanto o valor no contexto de criptografia, use a chave de condição `kms:EncryptionContext:context-key`.
Não é possível especificar um contexto de criptografia em uma operação criptográfica com uma [chave do KMS assimétrica](symmetric-asymmetric.md) ou uma [chave do KMS de Hash-based message authentication code (HMAC – Código de autenticação de mensagem por hash)](hmac.md). Algoritmos assimétricos e algoritmos de Message authentication code (MAC – Código de autenticação de mensagem) não são compatíveis com um contexto de criptografia.
**nota**
Os valores da chave de condição, incluindo uma chave de contexto de criptografia, devem estar em conformidade com as regras de caracteres e codificação das políticas de AWS KMS chaves. Talvez você não consiga usar essa chave de condição para expressar todas as chaves válidas de contexto de criptografia. Para obter detalhes sobre as regras de documento de política de chaves, consulte [Formato de política de chaves](key-policy-overview.md#key-policy-format). Para obter detalhes sobre as regras de documento de política do IAM, consulte [Requisitos de nome do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-quotas.html#reference_iam-quotas-names) no *Guia do usuário do IAM*.
Esta é uma [chave de condição de vários valores](#set-operators). Você pode especificar vários pares de contexto de criptografia em cada solicitação de API. `kms:EncryptionContextKeys` compara as chaves de contexto de criptografia na solicitação com o conjunto de chaves de contexto de criptografia na política. Para determinar como esses conjuntos são comparados, você deve fornecer um operador de conjunto `ForAnyValue` ou `ForAllValues` na condição de política. Para detalhes sobre os operadores de conjunto, consulte[Usar várias chaves e valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multi-key-or-value-conditions), no Manual do usuário do IAM.
+ `ForAnyValue`: pelo menos uma chave de contexto de criptografia na solicitação deve corresponder a uma chave de contexto de criptografia na condição da política. Outras chaves de contexto de criptografia são permitidas. Se a solicitação não tiver um contexto de criptografia, a condição não será atendida.
+ `ForAllValues`: cada chave de contexto de criptografia na solicitação deve corresponder a uma chave de contexto de criptografia na condição da política. Esse operador de conjunto limita as chaves de contexto de criptografia àquelas na condição de política. Ele não requer uma chave de contexto de criptografia, mas proíbe chaves de contexto de criptografia não especificadas.
O exemplo a seguir de instrução de política de chaves usa a chave de condição `kms:EncryptionContextKeys` com o operador de conjunto `ForAnyValue`. Essa instrução de política permite o uso de uma chave do KMS para as operações especificadas, mas somente quando pelo menos um dos pares de contextos de criptografia na solicitação inclui a chave `AppName`, independentemente do seu valor.
Por exemplo, essa instrução de política de chaves permite uma solicitação `GenerateDataKey` com dois pares de contextos de criptografia, `AppName=Helper` e `Project=Alpha`, pois o primeiro par de contextos de criptografia atende à condição. Uma solicitação com apenas `Project=Alpha` ou sem um contexto de criptografia falharia.
Como a operação de [StringEquals](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html)condição diferencia maiúsculas de minúsculas, essa declaração de política exige a ortografia e as maiúsculas e minúsculas da chave de contexto de criptografia. No entanto, você pode usar um operador de condição que ignora a capitalização da chave, como `StringEqualsIgnoreCase`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": [
"kms:Encrypt",
"kms:GenerateDataKey*"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"kms:EncryptionContextKeys": "AppName"
}
}
}
```
Você também pode usar a chave de condição `kms:EncryptionContextKeys` para exigir um contexto de criptografia (qualquer um) em operações de criptografia que usam a chave do KMS.
A instrução de política de exemplo a seguir usa a chave de condição `kms:EncryptionContextKeys` com o [Operador de condição nula](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Null) para permitir o acesso a uma chave do KMS apenas quando o contexto de criptografia na solicitação da API não é nulo. Essa condição não confere as chaves ou os valores do contexto de criptografia. Ela só verifica se o contexto de criptografia existe.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": [
"kms:Encrypt",
"kms:GenerateDataKey*"
],
"Resource": "*",
"Condition": {
"Null": {
"kms:EncryptionContextKeys": false
}
}
}
```
**Consulte também**
+ [*kms:EncryptionContext: chave de contexto*](#conditions-kms-encryption-context)
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
## kms:ExpirationModel
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ExpirationModel` | String | Valor único | `ImportKeyMaterial` | Políticas de chaves e políticas do IAM |
A chave de `kms:ExpirationModel` condição controla o acesso à [ImportKeyMaterial](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html)operação com base no valor do [ExpirationModel](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html#KMS-ImportKeyMaterial-request-ExpirationModel)parâmetro na solicitação.
`ExpirationModel` é um parâmetro opcional que determina se o material de chave importada expira. Os valores válidos são `KEY_MATERIAL_EXPIRES` e `KEY_MATERIAL_DOES_NOT_EXPIRE`. `KEY_MATERIAL_EXPIRES` é o valor padrão.
A data e a hora de expiração são determinadas pelo valor do [ValidTo](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html#KMS-ImportKeyMaterial-request-ValidTo)parâmetro. O parâmetro `ValidTo` só não será necessário se o valor do parâmetro `ExpirationModel` for `KEY_MATERIAL_DOES_NOT_EXPIRE`. Você também pode usar a chave de ValidTo condição [kms:](#conditions-kms-valid-to) para exigir uma data de expiração específica como condição de acesso.
A instrução de política exemplificada a seguir usa a chave de condição `kms:ExpirationModel` para permitir que os usuários importem o material de chave para uma chave do KMS somente quando a solicitação incluir o parâmetro `ExpirationModel` e seu valor for `KEY_MATERIAL_DOES_NOT_EXPIRE`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:ImportKeyMaterial",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ExpirationModel": "KEY_MATERIAL_DOES_NOT_EXPIRE"
}
}
}
```
Também é possível usar a chave de condição `kms:ExpirationModel` para permitir que os usuários importem o material de chave somente quando este expirar. A instrução de política de chave exemplificada a seguir usa a chave de condição `kms:ExpirationModel` com o [operador de condição Null](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition_operators.html#Conditions_Null) para permitir que os usuários importem o material de chave somente quando a solicitação não tiver um parâmetro `ExpirationModel`. O valor padrão para ExpirationModel é`KEY_MATERIAL_EXPIRES`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:ImportKeyMaterial",
"Resource": "*",
"Condition": {
"Null": {
"kms:ExpirationModel": true
}
}
}
```
**Consulte também**
+ [kms:ValidTo](#conditions-kms-valid-to)
+ [kms:WrappingAlgorithm](#conditions-kms-wrapping-algorithm)
+ [kms:WrappingKeySpec](#conditions-kms-wrapping-key-spec)
## kms:GrantConstraintType
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:GrantConstraintType` | String | Valor único | `CreateGrant` `RetireGrant` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para controlar o acesso à [CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)operação com base no tipo de [restrição de concessão](create-grant-overview.md#grant-constraints) na solicitação.
Ao criar uma concessão, você pode especificar uma restrição de concessão para permitir as operações permitidas pela concessão apenas quando um [contexto de criptografia](encrypt_context.md) específico existir. A restrição de concessão pode ser de dois tipos: `EncryptionContextEquals` ou `EncryptionContextSubset`. Você pode usar esta chave de condição para verificar se a solicitação contém um tipo ou outro.
**Importante**
Não inclua informações confidenciais ou sigilosas nesse campo. Esse campo pode ser exibido em texto simples em CloudTrail registros e outras saídas.
A instrução de política de chaves exemplificada a seguir usa a chave de condição `kms:GrantConstraintType` para permitir que os usuários criem concessões somente quando a solicitação incluir uma restrição de concessão `EncryptionContextEquals`. O exemplo mostra uma declaração de política em uma política de chaves.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/RoleForExampleApp"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:GrantConstraintType": "EncryptionContextEquals"
}
}
}
```
**Consulte também**
+ [*kms:EncryptionContext: chave de contexto*](#conditions-kms-encryption-context)
+ [kms:EncryptionContextKeys](#conditions-kms-encryption-context-keys)
+ [kms:GrantIsForAWSResource](#conditions-kms-grant-is-for-aws-resource)
+ [kms:GrantOperations](#conditions-kms-grant-operations)
+ [kms:GranteePrincipal](#conditions-kms-grantee-principal)
+ [kms:RetiringPrincipal](#conditions-kms-retiring-principal)
## kms:GrantIsForAWSResource
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:GrantIsForAWSResource` | Booleano | Valor único | `CreateGrant` `ListGrants` `RevokeGrant` | Políticas de chaves e políticas do IAM |
Permite ou nega permissão para as [RevokeGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html)operações [CreateGrant[ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html)](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html),, ou somente quando um [AWS serviço integrado AWS KMS](https://aws.amazon.com/kms/features/#AWS_Service_Integration) chama a operação em nome do usuário. Essa condição de política não permite que o usuário chame essas operações de concessão diretamente.
A declaração de política de chaves demonstrativa a seguir usa a chave de condição `kms:GrantIsForAWSResource`. Ele permite que AWS serviços integrados AWS KMS, como o Amazon EBS, criem concessões nessa chave KMS em nome do principal especificado.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": true
}
}
}
```
**Consulte também**
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
+ [kms:GrantOperations](#conditions-kms-grant-operations)
+ [kms:GranteePrincipal](#conditions-kms-grantee-principal)
+ [kms:RetiringPrincipal](#conditions-kms-retiring-principal)
## kms:GrantOperations
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:GrantOperations` | String | Vários valores | `CreateGrant` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para controlar o acesso à [CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)operação com base nas [operações de concessão](grants.md#terms-grant-operations) na solicitação. Por exemplo, é possível permitir que os usuários criem concessões que delegam permissão para criptografar, mas não para descriptografar. Para obter mais informações sobre concessões, consulte [Usar concessões](grants.md).
Esta é uma [chave de condição de vários valores](#set-operators). O `kms:GrantOperations` compara o conjunto de operações de concessão na solicitação `CreateGrant` para o conjunto de operações de concessão na política. Para determinar como esses conjuntos são comparados, você deve fornecer um operador de conjunto `ForAnyValue` ou `ForAllValues` na condição de política. Para detalhes sobre os operadores de conjunto, consulte[Usar várias chaves e valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multi-key-or-value-conditions), no Manual do usuário do IAM.
+ `ForAnyValue`: pelo menos uma operação de concessão na solicitação deve corresponder a uma das operações de concessão na condição da política. Outras operações de concessão são permitidas.
+ ForAllValues: cada operação de concessão na solicitação deve corresponder a uma operação de concessão na condição da política. Este operador de conjunto limita as operações de concessão àquelas especificadas na condição da política. Ele não requer uma operação de concessão, mas proíbe operações de concessão não especificadas.
ForAllValues também retorna verdadeiro quando não há operações de concessão na solicitação, mas `CreateGrant` não permite isso. Se o parâmetro `Operations` ausente ou tiver um valor nulo, o parâmetro `CreateGrant` falhará na solicitação.
A instrução de política de chaves exemplificada a seguir usa a chave de condição `kms:GrantOperations` para criar concessões somente quando as operações de concessões são `Encrypt` e/ou `ReEncryptTo`. Se a concessão incluir quaisquer outras operações, a solicitação `CreateGrant` falhará.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"kms:GrantOperations": [
"Encrypt",
"ReEncryptTo"
]
}
}
}
```
Se você alterar o operador de conjunto na condição de política para `ForAnyValue`, a instrução de política exigirá que pelo menos uma das operações de concessão na concessão seja `Encrypt` ou `ReEncryptTo`, mas permitirá outras operações de concessão, como `Decrypt` ou `ReEncryptFrom`.
**Consulte também**
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
+ [kms:GrantIsForAWSResource](#conditions-kms-grant-is-for-aws-resource)
+ [kms:GranteePrincipal](#conditions-kms-grantee-principal)
+ [kms:RetiringPrincipal](#conditions-kms-retiring-principal)
## kms:GranteePrincipal
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:GranteePrincipal` | String | Valor único | `CreateGrant` | Políticas do IAM e de chaves |
Você pode usar essa chave de condição para controlar o acesso à [CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)operação com base no valor do [GranteePrincipal](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html#KMS-CreateGrant-request-GranteePrincipal)parâmetro na solicitação. Por exemplo, é possível criar concessões para usar uma chave do KMS somente quando a entidade principal favorecida na solicitação `CreateGrant` corresponder à entidade principal especificada na instrução de condição.
Para especificar a entidade principal beneficiada, use o nome do recurso da Amazon (ARN) de uma entidade principal da AWS . Os principais válidos incluem usuários do IAM Contas da AWS, funções do IAM, usuários federados e usuários com funções assumidas. Para obter ajuda com a sintaxe do ARN para um diretor, consulte [IAM ARNs no Guia do](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) usuário do *IAM*.
A instrução de política de chaves exemplificada a seguir usa a chave de condição `kms:GranteePrincipal` para criar concessões para uma chave do KMS somente quando a entidade principal favorecida na concessão for `LimitedAdminRole`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:GranteePrincipal": "arn:aws:iam::111122223333:role/LimitedAdminRole"
}
}
}
```
**Consulte também**
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
+ [kms:GrantIsForAWSResource](#conditions-kms-grant-is-for-aws-resource)
+ [kms:GrantOperations](#conditions-kms-grant-operations)
+ [kms:RetiringPrincipal](#conditions-kms-retiring-principal)
## kms:KeyAgreementAlgorithm
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:KeyAgreementAlgorithm` | String | Valor único | `DeriveSharedSecret` | Políticas de chaves e políticas do IAM |
Você pode usar a chave de `kms:KeyAgreementAlgorithm` condição para controlar o acesso à [DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html)operação com base no valor do `KeyAgreementAlgorithm` parâmetro na solicitação. O único valor válido para `KeyAgreementAlgorithm` é `ECDH`.
Por exemplo, a declaração de política chave a seguir usa a chave de `kms:KeyAgreementAlgorithm` condição para negar todo o acesso, a DeriveSharedSecret menos que `KeyAgreementAlgorithm` seja`ECDH`.
```
{
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:DeriveSharedSecret",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"kms:KeyAgreementAlgorithm": "ECDH"
}
}
}
```
**Consulte também**
+ [kms:KeyUsage](#conditions-kms-key-usage)
## kms:KeyOrigin
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:KeyOrigin` | String | Valor único | `CreateKey` Operações de recursos de chaves do KMS | Políticas do IAM Políticas de chaves e políticas do IAM |
A chave de condição `kms:KeyOrigin` controla o acesso às operações com base no valor da propriedade `Origin` da chave do KMS que é criada pela operação ou usada nela. Ela funciona como uma condição de recurso ou de solicitação.
Você pode usar essa chave de condição para controlar o acesso à [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação com base no valor do parâmetro [Origin](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html#KMS-CreateKey-request-Origin) na solicitação. Os valores válidos para `Origin` são `AWS_KMS`, `AWS_CLOUDHSM`, `EXTERNAL_KEY_STORE` e `EXTERNAL`.
Por exemplo, você pode criar uma chave KMS somente quando o material da chave é gerado em AWS KMS (`AWS_KMS`), somente quando o material da chave é gerado em um AWS CloudHSM cluster associado a um armazenamento de [chaves personalizado do CloudHSM](key-store-overview.md#custom-key-store-overview) `AWS_CLOUDHSM` (), somente quando o material da chave é gerado em [um armazenamento de chaves externo](key-store-overview.md#custom-key-store-overview) `EXTERNAL_KEY_STORE` () ou somente quando [o material da chave é](importing-keys.md) importado de uma fonte externa (). `EXTERNAL`
O exemplo de declaração de política de chaves a seguir usa a chave de `kms:KeyOrigin` condição para criar uma chave KMS somente quando AWS KMS cria o material da chave.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:CreateKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:KeyOrigin": "AWS_KMS"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:GenerateDataKeyPair",
"kms:GenerateDataKeyPairWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource": "arn:aws:kms:us-west-2:111122223333:key/*",
"Condition": {
"StringEquals": {
"kms:KeyOrigin": "AWS_CLOUDHSM"
}
}
}
]
}
```
------
Também é possível usar a chave de condição `kms:KeyOrigin` para controlar o acesso a operações que usam ou gerenciam uma chave do KMS com base na propriedade `Origin` da chave do KMS usada para a operação. A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação.
Por exemplo, a política do IAM a seguir permite que as entidades principais realizem as operações de recursos de chave do KMS especificadas, mas somente com as chaves do KMS na conta que foram criadas em um armazenamento de chaves personalizado.
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:GenerateDataKeyWithoutPlaintext",
"kms:GenerateDataKeyPair",
"kms:GenerateDataKeyPairWithoutPlaintext",
"kms:ReEncrypt*"
],
"Resource": "arn:aws:kms:us-west-2:111122223333:key/*",
"Condition": {
"StringEquals": {
"kms:KeyOrigin": "AWS_CLOUDHSM"
}
}
}
```
**Consulte também**
+ [kms:BypassPolicyLockoutSafetyCheck](#conditions-kms-bypass-policy-lockout-safety-check)
+ [kms:KeySpec](#conditions-kms-key-spec)
+ [kms:KeyUsage](#conditions-kms-key-usage)
## kms:KeySpec
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:KeySpec` | String | Valor único | `CreateKey` Operações de recursos de chaves do KMS | Políticas do IAM Políticas de chaves e políticas do IAM |
A chave de condição `kms:KeySpec` controla o acesso às operações com base no valor da propriedade `KeySpec` da chave do KMS que é criada pela operação ou usada nela.
Você pode usar essa chave de condição em uma política do IAM para controlar o acesso à [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação com base no valor do [KeySpec](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html#KMS-CreateKey-request-KeySpec)parâmetro em uma `CreateKey` solicitação. Por exemplo, é possível usar essa condição para permitir que os usuários criem somente chaves do KMS de criptografia simétrica ou somente chaves do KMS de HMAC.
O seguinte exemplo de instrução de política do IAM usa a chave de condição `kms:KeySpec` para permitir que as entidades principais criem apenas chaves do KMS assimétricas RSA. A permissão só é válida quando o `KeySpec` na solicitação começa com `RSA_`.
```
{
"Effect": "Allow",
"Action": "kms:CreateKey",
"Resource": "*",
"Condition": {
"StringLike": {
"kms:KeySpec": "RSA_*"
}
}
}
```
Também é possível usar a chave de condição `kms:KeySpec` para controlar o acesso a operações que usam ou gerenciam uma chave do KMS com base na propriedade `KeySpec` da chave do KMS usada para a operação. A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação.
Por exemplo, a seguinte política do IAM permite que as entidades principais executem as operações especificadas de recursos de chave do KMS, mas somente com chaves do KMS de criptografia simétrica na conta.
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:DescribeKey"
],
"Resource": "arn:aws:kms:us-west-2:111122223333:key/*",
"Condition": {
"StringEquals": {
"kms:KeySpec": "SYMMETRIC_DEFAULT"
}
}
}
```
**Consulte também**
+ [kms:BypassPolicyLockoutSafetyCheck](#conditions-kms-bypass-policy-lockout-safety-check)
+ [kms: CustomerMasterKeySpec (obsoleto)](#conditions-kms-key-spec-replaced)
+ [kms:DataKeyPairSpec](#conditions-kms-data-key-spec)
+ [kms:KeyOrigin](#conditions-kms-key-origin)
+ [kms:KeyUsage](#conditions-kms-key-usage)
## kms:KeyUsage
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:KeyUsage` | String | Valor único | `CreateKey` Operações de recursos de chaves do KMS | Políticas do IAM Políticas de chaves e políticas do IAM |
A chave de condição `kms:KeyUsage` controla o acesso às operações com base no valor da propriedade `KeyUsage` da chave do KMS que é criada pela operação ou usada nela.
Você pode usar essa chave de condição para controlar o acesso à [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação com base no valor do [KeyUsage](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html#KMS-CreateKey-request-KeyUsage)parâmetro na solicitação. Os valores válidos para `KeyUsage` são `ENCRYPT_DECRYPT`, `SIGN_VERIFY`, `GENERATE_VERIFY_MAC` e `KEY_AGREEMENT`.
Por exemplo, será possível criar uma chave do KMS somente quando `KeyUsage` for `ENCRYPT_DECRYPT` ou negar a permissão de um usuário quando `KeyUsage` for `SIGN_VERIFY`.
A instrução de política do IAM exemplificada a seguir usa a chave de condição `kms:KeyUsage` para criar uma chave do KMS somente quando `KeyUsage` for `ENCRYPT_DECRYPT`.
```
{
"Effect": "Allow",
"Action": "kms:CreateKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:KeyUsage": "ENCRYPT_DECRYPT"
}
}
}
```
Também é possível usar a chave de condição `kms:KeyUsage` para controlar o acesso a operações que usam ou gerenciam uma chave do KMS com base na propriedade `KeyUsage` da chave do KMS na operação. A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação.
Por exemplo, a política do IAM a seguir permite que as entidades principais realizem as operações de recursos de chaves do KMS especificadas, mas somente com as chaves do KMS na conta que são usadas para assinatura e verificação.
```
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:DescribeKey",
"kms:GetPublicKey",
"kms:ScheduleKeyDeletion"
],
"Resource": "arn:aws:kms:us-west-2:111122223333:key/*",
"Condition": {
"StringEquals": {
"kms:KeyUsage": "SIGN_VERIFY"
}
}
}
```
**Consulte também**
+ [kms:BypassPolicyLockoutSafetyCheck](#conditions-kms-bypass-policy-lockout-safety-check)
+ [kms: CustomerMasterKeyUsage (obsoleto)](#conditions-kms-key-usage-replaced)
+ [kms:KeyOrigin](#conditions-kms-key-origin)
+ [kms:KeySpec](#conditions-kms-key-spec)
## kms:MacAlgorithm
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:MacAlgorithm` | String | Valor único | `GenerateMac``VerifyMac` | Políticas de chaves e políticas do IAM |
Você pode usar a chave de `kms:MacAlgorithm` condição para controlar o acesso às [VerifyMac](https://docs.aws.amazon.com/kms/latest/APIReference/API_VerifyMac.html)operações [GenerateMac](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateMac.html)e com base no valor do `MacAlgorithm` parâmetro na solicitação.
O seguinte exemplo de política de chaves permite que usuários capazes de assumir a função `testers` só usem a chave do KMS de HMAC para gerar e verificar etiquetas HMAC quando o algoritmo de MAC na solicitação for `HMAC_SHA_384` ou `HMAC_SHA_512`. Essa política usa duas instruções distintas de política, cada uma com sua própria condição. Se você especificar mais de um algoritmo de MAC em uma única instrução de condição, a condição exigirá ambos os algoritmos em vez de um ou outro.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/testers"
},
"Action": [
"kms:GenerateMac",
"kms:VerifyMac"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:MacAlgorithm": "HMAC_SHA_384"
}
}
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/testers"
},
"Action": [
"kms:GenerateMac",
"kms:VerifyMac"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:MacAlgorithm": "HMAC_SHA_512"
}
}
}
]
}
```
------
**Consulte também**
+ [kms:EncryptionAlgorithm](#conditions-kms-encryption-algorithm)
+ [kms:SigningAlgorithm](#conditions-kms-signing-algorithm)
## kms:MessageType
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:MessageType` | String | Valor único | `Sign` `Verify` | Políticas de chaves e políticas do IAM |
A chave de condição `kms:MessageType` controla o acesso às operações [Sign](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html) e [Verify](https://docs.aws.amazon.com/kms/latest/APIReference/API_Verify.html) com base no valor do parâmetro `MessageType` na solicitação. Os valores válidos para `MessageType` são `RAW` e `DIGEST`.
Por exemplo, a instrução de política de chaves a seguir usa a chave de condição `kms:MessageType` para usar uma chave do KMS assimétrica para assinar uma mensagem, mas não um resumo da mensagem.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:Sign",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:MessageType": "RAW"
}
}
}
```
**Consulte também**
+ [kms:SigningAlgorithm](#conditions-kms-signing-algorithm)
## kms:MultiRegion
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:MultiRegion` | Booleano | Valor único | `CreateKey` Operações de recursos de chaves do KMS | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para permitir operações somente em chaves de região única ou somente em [chaves de várias regiões](multi-region-keys-overview.md). A chave de `kms:MultiRegion` condição controla o acesso às AWS KMS operações nas chaves KMS e à [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação com base no valor da `MultiRegion` propriedade da chave KMS. Os valores válidos são `true` (várias regiões) e `false` (região única). Todas as chaves do KMS têm uma propriedade `MultiRegion`.
Por exemplo, a seguinte instrução de política do IAM usa a chave de condição `kms:MultiRegion` para permitir que as entidades principais criem apenas chaves de região única.
```
{
"Effect": "Allow",
"Action": "kms:CreateKey",
"Resource": "*",
"Condition": {
"Bool": {
"kms:MultiRegion": false
}
}
}
```
## kms:MultiRegionKeyType
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:MultiRegionKeyType` | String | Valor único | `CreateKey` Operações de recursos de chaves do KMS | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para permitir operações somente em [chaves primárias de várias regiões](multi-region-keys-overview.md#mrk-primary-key) ou somente em [chaves de réplica de várias regiões](multi-region-keys-overview.md#mrk-replica-key). A chave de `kms:MultiRegionKeyType` condição controla o acesso às AWS KMS operações nas chaves KMS e a [CreateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateKey.html)operação com base na `MultiRegionKeyType` propriedade da chave KMS. Os valores válidos são `PRIMARY` e `REPLICA`. Somente chaves de várias regiões têm uma propriedade `MultiRegionKeyType`.
Normalmente, você pode usar a chave de condição `kms:MultiRegionKeyType` em uma política do IAM para controlar o acesso a várias chaves do KMS. No entanto, como uma determinada chave de várias regiões pode mudar para primária ou réplica, convém usar essa condição em uma política de chaves para permitir uma operação somente quando a chave de várias regiões específica for uma chave primária ou de réplica.
Por exemplo, a instrução de política do IAM a seguir usa a chave de condição `kms:MultiRegionKeyType` para permitir que as entidades principais programem e cancelem a exclusão de chaves somente em chaves de réplica de várias regiões na Conta da AWS especificada.
```
{
"Effect": "Allow",
"Action": [
"kms:ScheduleKeyDeletion",
"kms:CancelKeyDeletion"
],
"Resource": "arn:aws:kms:*:111122223333:key/*",
"Condition": {
"StringEquals": {
"kms:MultiRegionKeyType": "REPLICA"
}
}
}
```
Para permitir ou negar acesso a todas as chaves de várias regiões, você pode usar ambos os valores ou um valor nulo com `kms:MultiRegionKeyType`. No entanto, a chave de MultiRegion condição [kms:](#conditions-kms-multiregion) é recomendada para essa finalidade.
## kms:PrimaryRegion
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:PrimaryRegion` | String (lista) | Valor único | `UpdatePrimaryRegion` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para limitar as regiões de destino em uma [UpdatePrimaryRegion](https://docs.aws.amazon.com/kms/latest/APIReference/API_UpdatePrimaryRegion.html)operação. São elas Regiões da AWS que podem hospedar suas chaves primárias multirregionais.
A chave de `kms:PrimaryRegion` condição controla o acesso à [UpdatePrimaryRegion](https://docs.aws.amazon.com/kms/latest/APIReference/API_UpdatePrimaryRegion.html)operação com base no valor do `PrimaryRegion` parâmetro. O `PrimaryRegion` parâmetro especifica a [chave Região da AWS de réplica multirregional](multi-region-keys-overview.md#mrk-replica-key) que está sendo promovida para primária. O valor da condição é um ou mais Região da AWS nomes, como `us-east-1` ou`ap-southeast-2`, ou padrões de nome de região, como `eu-*`
Por exemplo, a instrução de política de chaves a seguir usa a chave de condição `kms:PrimaryRegion` para permitir que as entidades principais atualizem a região primária de uma chave de várias regiões para uma das quatro regiões especificadas.
```
{
"Effect": "Allow",
"Action": "kms:UpdatePrimaryRegion",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/Developer"
},
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:PrimaryRegion": [
"us-east-1",
"us-west-2",
"eu-west-3",
"ap-southeast-2"
]
}
}
}
```
## kms:ReEncryptOnSameKey
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ReEncryptOnSameKey` | Booleano | Valor único | `ReEncrypt` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para controlar o acesso à [ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html)operação com base no fato de a solicitação especificar uma chave KMS de destino que seja a mesma usada para a criptografia original.
Por exemplo, a instrução de política de chaves a seguir usa a chave de condição `kms:ReEncryptOnSameKey` para criptografar novamente somente quando a chave do KMS de destino é semelhante à usada para a criptografia original.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:ReEncrypt*",
"Resource": "*",
"Condition": {
"Bool": {
"kms:ReEncryptOnSameKey": true
}
}
}
```
## kms:RequestAlias
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:RequestAlias` | String (lista) | Valor único | [Operações criptográficas](kms-cryptography.md#cryptographic-operations) [DescribeKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html) [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) | Políticas de chaves e políticas do IAM |
É possível usar essa chave de condição para permitir uma operação somente quando a solicitação usa um alias específico para identificar a chave do KMS. A chave de condição `kms:RequestAlias` controla o acesso a uma chave do KMS usada em uma operação criptográfica, `GetPublicKey` ou `DescribeKey` com base no [alias](kms-alias.md) que identifica essa chave do KMS na solicitação. (Essa condição de política não tem efeito na [GenerateRandom](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateRandom.html)operação porque a operação não usa uma chave ou alias KMS.)
Essa condição oferece suporte [ao controle de acesso baseado em atributos](abac.md) (ABAC) em AWS KMS, que permite controlar o acesso às chaves KMS com base nas tags e aliases de uma chave KMS. Você pode usar tags e aliases para conceder ou negar acesso a uma chave do KMS sem alterar políticas ou permissões. Para obter detalhes, consulte [ABAC para AWS KMS](abac.md).
Para especificar o alias nessa condição de política, use um [nome de alias](concepts.md#key-id-alias-name), como `alias/project-alpha`, ou um padrão de nome de alias, como `alias/*test*`. Não é possível especificar um [ARN de alias](concepts.md#key-id-alias-ARN) no valor dessa chave de condição.
Para satisfazer essa condição, o valor do parâmetro`KeyId` na solicitação deve ser um nome de alias correspondente ou um ARN de alias. Se a solicitação usar um[identificador de chave](concepts.md#key-id) diferente, ela não atenderá à condição, mesmo que identifique a mesma chave do KMS.
Por exemplo, a declaração de política chave a seguir permite que o diretor chame a [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)operação na chave KMS. No entanto, isso é permitido somente quando o valor do parâmetro `KeyId` na solicitação é `alias/finance-key` ou um ARN de alias com esse nome de alias, como `arn:aws:kms:us-west-2:111122223333:alias/finance-key`.
```
{
"Sid": "Key policy using a request alias condition",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/developer"
},
"Action": "kms:GenerateDataKey",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:RequestAlias": "alias/finance-key"
}
}
}
```
Você não pode usar essa chave de condição para controlar o acesso às operações de alias, como [CreateAlias](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateAlias.html)ou [DeleteAlias](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeleteAlias.html). Para obter informações sobre como controlar o acesso a todas as operações de alias, consulte [Controlar o acesso a aliases](alias-access.md).
## kms:ResourceAliases
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ResourceAliases` | String (lista) | Vários valores | Operações de recursos de chaves do KMS | Somente políticas do IAM |
Use essa chave de condição para controlar o acesso a uma chave do KMS com base nos [aliases](kms-alias.md) que estão associados à chave do KMS. A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação.
Essa condição oferece suporte ao controle de acesso baseado em atributos (ABAC) no AWS KMS. Com o ABAC, você pode controlar o acesso a chaves do KMS com base nas etiquetas atribuídas a uma chave do KMS e nos aliases associados a uma chave do KMS. Você pode usar tags e aliases para conceder ou negar acesso a uma chave do KMS sem alterar políticas ou permissões. Para obter detalhes, consulte [ABAC para AWS KMS](abac.md).
Um alias deve ser exclusivo em uma região Conta da AWS e, mas essa condição permite controlar o acesso a várias chaves KMS na mesma região (usando o operador de `StringLike` comparação) ou a várias chaves KMS em diferentes contas Regiões da AWS .
**nota**
A ResourceAliases condição [kms:](#conditions-kms-resource-aliases) é efetiva somente quando a chave KMS está em conformidade com os [aliases por](resource-limits.md#aliases-per-key) cota de chave KMS. Se uma chave do KMS exceder essa cota, as entidades principais autorizadas a usar essa chave pela condição `kms:ResourceAliases` terão acesso negado a ela.
Para especificar o alias nessa condição de política, use um [nome de alias](concepts.md#key-id-alias-name), como `alias/project-alpha`, ou um padrão de nome de alias, como `alias/*test*`. Não é possível especificar um [ARN de alias](concepts.md#key-id-alias-ARN) no valor dessa chave de condição. Para atender à condição, a chave do KMS usada na operação deve ter o alias especificado. Não importa se ou como a chave do KMS é identificada na solicitação para a operação.
Esta é uma chave de condição de vários valores que compara o conjunto de aliases associados a uma chave do KMS com o conjunto de aliases na política. Para determinar como esses conjuntos são comparados, você deve fornecer um operador de conjunto `ForAnyValue` ou `ForAllValues` na condição de política. Para detalhes sobre os operadores de conjunto, consulte[Usar várias chaves e valores](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_multi-value-conditions.html#reference_policies_multi-key-or-value-conditions), no Manual do usuário do IAM.
+ ForAnyValue: pelo menos um alias associado à chave KMS deve corresponder a um alias na condição da política. Outros aliases são permitidos. Se a chave do KMS não tiver alias, a condição não será atendida.
+ ForAllValues: cada alias associado à chave KMS deve corresponder a um alias na política. Esse operador de conjunto limita os aliases associados à chave do KMS àqueles na condição da política. Ele não requer aliases, mas proíbe aliases não especificados.
Por exemplo, a declaração de política do IAM a seguir permite que o diretor chame a [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)operação em qualquer chave KMS especificada Conta da AWS associada ao `finance-key` alias. (As políticas de chaves das chaves do KMS afetadas também devem permitir que a conta da entidade principal as use para essa operação.) Para indicar que a condição é atendida quando um dos muitos aliases que podem estar associados à chave do KMS é `alias/finance-key`, a condição usa o operador de conjunto `ForAnyValue`.
Como a condição `kms:ResourceAliases` é baseada no recurso, não na solicitação, uma chamada para `GenerateDataKey` é bem-sucedida para qualquer chave do KMS associada ao alias `finance-key`, mesmo que a solicitação use um [ID de chave](concepts.md#key-id-key-id) ou um [ ARN de chave](concepts.md#key-id-key-ARN) para identificar a chave do KMS.
```
{
"Sid": "AliasBasedIAMPolicy",
"Effect": "Allow",
"Action": "kms:GenerateDataKey",
"Resource": [
"arn:aws:kms:*:111122223333:key/*",
"arn:aws:kms:*:444455556666:key/*"
],
"Condition": {
"ForAnyValue:StringEquals": {
"kms:ResourceAliases": "alias/finance-key"
}
}
}
```
O seguinte exemplo de instrução de política do IAM permite que a entidade principal habilite e desabilite chaves do KMS, mas somente quando todos os aliases das chaves do KMS incluem “`Test`”. Essa instrução de política usa duas condições. A condição com o operador de conjunto `ForAllValues` requer que todos os aliases associados à chave do KMS incluam “Test”. A condição com o operador de conjunto `ForAnyValue` requer que a chave do KMS tenha pelo menos um alias com “Test”. Sem a condição `ForAnyValue`, essa instrução de política teria permitido que a entidade principal usasse chaves do KMS sem aliases.
```
{
"Sid": "AliasBasedIAMPolicy",
"Effect": "Allow",
"Action": [
"kms:EnableKey",
"kms:DisableKey"
],
"Resource": "arn:aws:kms:*:111122223333:key/*",
"Condition": {
"ForAllValues:StringLike": {
"kms:ResourceAliases": [
"alias/*Test*"
]
},
"ForAnyValue:StringLike": {
"kms:ResourceAliases": [
"alias/*Test*"
]
}
}
}
```
## kms:ReplicaRegion
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ReplicaRegion` | String (lista) | Valor único | `ReplicateKey` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para limitar a Regiões da AWS possibilidade de um principal replicar uma chave [multirregional](multi-region-keys-overview.md). A chave de `kms:ReplicaRegion` condição controla o acesso à [ReplicateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)operação com base no valor do [ReplicaRegion](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html#KMS-CreateGrant-request-RetiringPrincipal)parâmetro na solicitação. Esse parâmetro especifica a propriedade Região da AWS da nova [chave de réplica](multi-region-keys-overview.md#mrk-replica-key).
O valor da condição é um ou mais Região da AWS nomes, como `us-east-1` ou`ap-southeast-2`, ou padrões de nomes, como`eu-*`. Para obter uma lista dos nomes desses Regiões da AWS AWS KMS suportes, consulte [AWS Key Management Service endpoints e cotas](https://docs.aws.amazon.com/general/latest/gr/kms.html) no. Referência geral da AWS
Por exemplo, a declaração de política de chaves a seguir usa a chave de `kms:ReplicaRegion` condição para permitir que os diretores chamem a [ReplicateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReplicateKey.html)operação somente quando o valor do `ReplicaRegion` parâmetro for uma das regiões especificadas.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/Administrator"
},
"Action": "kms:ReplicateKey"
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ReplicaRegion": [
"us-east-1",
"eu-west-3",
"ap-southeast-2"
]
}
}
}
```
Essa chave de condição controla o acesso somente à [ReplicateKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReplicateKey.html)operação. Para controlar o acesso à [UpdatePrimaryRegion](https://docs.aws.amazon.com/kms/latest/APIReference/API_UpdatePrimaryRegion.html)operação, use a chave de PrimaryRegion condição [kms:](#conditions-kms-primary-region).
## kms:RetiringPrincipal
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:RetiringPrincipal` | String (lista) | Valor único | `CreateGrant` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para controlar o acesso à [CreateGrant](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html)operação com base no valor do [RetiringPrincipal](https://docs.aws.amazon.com/kms/latest/APIReference/API_CreateGrant.html#KMS-CreateGrant-request-RetiringPrincipal)parâmetro na solicitação. Por exemplo, é possível criar concessões para usar uma chave do KMS somente quando `RetiringPrincipal` na solicitação `CreateGrant` corresponder a `RetiringPrincipal` na instrução da condição.
Para especificar a entidade principal em processo de desativação, use o ARN de uma entidade principal da AWS . Os principais válidos incluem usuários do IAM Contas da AWS, funções do IAM, usuários federados e usuários com funções assumidas. Para obter ajuda com a sintaxe do ARN para um diretor, consulte [IAM ARNs no Guia do](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-arns) usuário do *IAM*.
O exemplo de declaração de política de chave a seguir permite que um usuário crie concessões para a chave do KMS. A chave de condição `kms:RetiringPrincipal` restringe a permissão a solicitações `CreateGrant` nas quais a entidade principal em processo de desativação na concessão é `LimitedAdminRole`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:CreateGrant",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:RetiringPrincipal": "arn:aws:iam::111122223333:role/LimitedAdminRole"
}
}
}
```
**Consulte também**
+ [kms:GrantConstraintType](#conditions-kms-grant-constraint-type)
+ [kms:GrantIsForAWSResource](#conditions-kms-grant-is-for-aws-resource)
+ [kms:GrantOperations](#conditions-kms-grant-operations)
+ [kms:GranteePrincipal](#conditions-kms-grantee-principal)
## kms:RotationPeriodInDays
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:RotationPeriodInDays` | Numérico | Valor único | `EnableKeyRotation` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para limitar os valores que os diretores podem especificar no `RotationPeriodInDays` parâmetro de uma [EnableKeyRotation](https://docs.aws.amazon.com/kms/latest/APIReference/API_EnableKeyRotation.html)solicitação.
`RotationPeriodInDays`Especifica o número de dias entre cada data de rotação automática da chave. AWS KMS permite especificar um período de rotação entre 90 e 2560 dias, mas você pode usar a chave de `kms:RotationPeriodInDays` condição para restringir ainda mais o período de rotação, como impor um período mínimo de rotação dentro do intervalo válido.
Por exemplo, a declaração de política de chave a seguir usa a chave de condição `kms:RotationPeriodInDays` para impedir que entidades principais habilitem a alternância de chave se o período de alternância for menor ou igual a 180 dias.
```
{
"Effect": "Deny",
"Action": "kms:EnableKeyRotation",
"Principal": "*",
"Resource": "*",
"Condition" : {
"NumericLessThanEquals" : {
"kms:RotationPeriodInDays" : "180"
}
}
}
```
## kms:ScheduleKeyDeletionPendingWindowInDays
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ScheduleKeyDeletionPendingWindowInDays` | Numérico | Valor único | `ScheduleKeyDeletion` | Políticas de chaves e políticas do IAM |
Você pode usar essa chave de condição para limitar os valores que os diretores podem especificar no `PendingWindowInDays` parâmetro de uma [ScheduleKeyDeletion](https://docs.aws.amazon.com/kms/latest/APIReference/API_ScheduleKeyDeletion.html)solicitação.
`PendingWindowInDays`Especifica o número de dias que AWS KMS serão esperados antes de excluir uma chave. AWS KMS permite especificar um período de espera entre 7 e 30 dias, mas você pode usar a chave de `kms:ScheduleKeyDeletionPendingWindowInDays` condição para restringir ainda mais o período de espera, como impor um período mínimo de espera dentro do intervalo válido.
Por exemplo, a declaração de política de chave a seguir usa a chave de condição `kms:ScheduleKeyDeletionPendingWindowInDays` para impedir que a entidade principal programe a exclusão da chave se o período de espera for menor ou igual a 21 dias.
```
{
"Effect": "Deny",
"Action": "kms:ScheduleKeyDeletion",
"Principal": "*",
"Resource": "*",
"Condition" : {
"NumericLessThanEquals" : {
"kms:ScheduleKeyDeletionPendingWindowInDays" : "21"
}
}
}
```
## kms:SigningAlgorithm
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:SigningAlgorithm` | String | Valor único | `Sign` `Verify` | Políticas de chaves e políticas do IAM |
Você pode usar a chave de `kms:SigningAlgorithm` condição para controlar o acesso às operações de [Assinar](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html) e [Verificar](https://docs.aws.amazon.com/kms/latest/APIReference/API_Verify.html) com base no valor do [SigningAlgorithm](https://docs.aws.amazon.com/kms/latest/APIReference/API_Sign.html#KMS-Sign-request-SigningAlgorithm)parâmetro na solicitação. Essa chave de condição não tem efeito nas operações realizadas fora da AWS KMS, como a verificação de assinaturas com a chave pública em um par de chaves KMS assimétrico fora da. AWS KMS
O exemplo de política de chaves a seguir permite que os usuários que podem assumir a função `testers` usem a chave do KMS para assinar mensagens somente quando o algoritmo de assinatura usado para a solicitação é um algoritmo RSASSA\$1PSS, como `RSASSA_PSS_SHA512`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/testers"
},
"Action": "kms:Sign",
"Resource": "*",
"Condition": {
"StringLike": {
"kms:SigningAlgorithm": "RSASSA_PSS*"
}
}
}
```
**Consulte também**
+ [kms:EncryptionAlgorithm](#conditions-kms-encryption-algorithm)
+ [kms:MacAlgorithm](#conditions-kms-mac-algorithm)
+ [kms:MessageType](#conditions-kms-message-type)
## kms:ValidTo
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ValidTo` | Timestamp | Valor único | `ImportKeyMaterial` | Políticas de chaves e políticas do IAM |
A chave de `kms:ValidTo` condição controla o acesso à [ImportKeyMaterial](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html)operação com base no valor do [ValidTo](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html#KMS-ImportKeyMaterial-request-ValidTo)parâmetro na solicitação, que determina quando o material da chave importada expira. O valor é expresso no [horário do Unix](https://en.wikipedia.org/wiki/Unix_time).
Por padrão, o parâmetro `ValidTo` é obrigatório em uma solicitação `ImportKeyMaterial`. No entanto, se o valor do [ExpirationModel](https://docs.aws.amazon.com/kms/latest/APIReference/API_ImportKeyMaterial.html#KMS-ImportKeyMaterial-request-ExpirationModel)parâmetro for`KEY_MATERIAL_DOES_NOT_EXPIRE`, o `ValidTo` parâmetro é inválido. Você também pode usar a chave de ExpirationModel condição [kms:](#conditions-kms-expiration-model) para exigir o `ExpirationModel` parâmetro ou um valor de parâmetro específico.
A seguinte instrução de política de exemplo permite a um usuário importar material-chave em uma chave do KMS. A chave de condição `kms:ValidTo` limita a permissão para solicitações `ImportKeyMaterial` em que o valor `ValidTo` é menor que ou igual a `1546257599.0` (31 de dezembro de 2018 23:59:59).
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:ImportKeyMaterial",
"Resource": "*",
"Condition": {
"NumericLessThanEquals": {
"kms:ValidTo": "1546257599.0"
}
}
}
```
**Consulte também**
+ [kms:ExpirationModel](#conditions-kms-expiration-model)
+ [kms:WrappingAlgorithm](#conditions-kms-wrapping-algorithm)
+ [kms:WrappingKeySpec](#conditions-kms-wrapping-key-spec)
## kms:ViaService
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:ViaService` | String | Valor único | Operações de recursos de chaves do KMS | Políticas de chaves e políticas do IAM |
A chave de `kms:ViaService` condição limita o uso de uma chave KMS às solicitações Serviços da AWS especificadas. Essa chave de condição se aplica somente às [sessões de acesso direto](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html). Você pode especificar um ou mais serviços em cada chave de condição `kms:ViaService`. A operação deve ser uma *operação de recurso de chave do KMS*, ou seja, uma operação autorizada para uma chave do KMS específica. Para identificar as operações de recursos de chaves do KMS, na [Tabela de ações e recursos](kms-api-permissions-reference.md#kms-api-permissions-reference-table), procure um valor de `KMS key` na coluna `Resources` para a operação.
Por exemplo, a seguinte instrução de política de chaves usa a chave de condição `kms:ViaService` para permitir que uma [chave gerenciada pelo cliente](concepts.md#customer-mgn-key) seja usada para as ações especificadas somente quando a solicitação vem do Amazon EC2 ou do Amazon RDS na região Oeste dos EUA (Oregon) em nome de `ExampleRole`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:CreateGrant",
"kms:ListGrants",
"kms:DescribeKey"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": [
"ec2.us-west-2.amazonaws.com",
"rds.us-west-2.amazonaws.com"
]
}
}
}
```
Também é possível usar uma chave de condição `kms:ViaService` para negar permissão para usar uma chave do KMS quando a solicitação é proveniente de serviços específicos. Por exemplo, a instrução de política a seguir usa uma chave de condição `kms:ViaService` para impedir que uma chave gerenciada pelo cliente seja usada para operações `Encrypt` quando a solicitação é proveniente do AWS Lambda em nome de `ExampleRole`.
```
{
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": [
"kms:Encrypt"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:ViaService": [
"lambda.us-west-2.amazonaws.com"
]
}
}
}
```
**Importante**
Quando você usa a chave de condição `kms:ViaService`, o serviço faz a solicitação em nome de uma entidade principal na conta da Conta da AWS. Essas entidades principais deve ter as seguintes permissões:
Permissão para usar a chave do KMS. A entidade principal precisa conceder essas permissões ao serviço integrado, de forma que o serviço possa usar a chave gerenciada pelo cliente em nome da entidade principal. Para obter mais informações, consulte [Usando AWS KMS criptografia com AWS serviços](service-integration.md).
Permissão para usar o serviço integrado. Para obter detalhes sobre como dar aos usuários acesso a um AWS serviço que se integra ao AWS KMS, consulte a documentação do serviço integrado.
Todas as [Chaves gerenciadas pela AWS](concepts.md#aws-managed-key) usam uma chave de condição `kms:ViaService` no seu documento de política de chaves. Essa condição permite que a chave do KMS seja usada apenas para solicitações provenientes do serviço que criou a chave do KMS. Para ver a política principal de um Chave gerenciada pela AWS, use a [GetKeyPolicy](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetKeyPolicy.html)operação.
A chave de condição `kms:ViaService` é válida no IAM e em declarações de políticas de chaves. Os serviços que você especificar devem ser [integrados ao AWS KMS](https://aws.amazon.com/kms/features/#AWS_Service_Integration) e compatíveis com a chave de condição `kms:ViaService`.
### Serviços que oferecem suporte à chave de condição `kms:ViaService`
A tabela a seguir lista AWS os serviços que estão integrados AWS KMS e oferecem suporte ao uso da chave de `kms:ViaService` condição nas chaves gerenciadas pelo cliente. Os serviços desta tabela podem não estar disponíveis em todas as regiões. Use o `.amazonaws.com` sufixo do AWS KMS ViaService nome em todas as AWS partições.
**nota**
Talvez seja necessário rolar horizontalmente ou verticalmente para ver todos os dados nessa tabela.
| Nome do serviço | AWS KMS ViaService nome |
| --- | --- |
| Operações de IA da Amazon | aiops.AWS\$1region.amazonaws.com |
| AWS App Runner | apprunner.AWS\$1region.amazonaws.com |
| AWS AppFabric | appfabric.AWS\$1region.amazonaws.com |
| Amazon AppFlow | appflow.AWS\$1region.amazonaws.com |
| AWS Application Migration Service | mgn.AWS\$1region.amazonaws.com |
| Amazon Athena | athena.AWS\$1region.amazonaws.com |
| AWS Audit Manager | auditmanager.AWS\$1region.amazonaws.com |
| Amazon Aurora | rds.AWS\$1region.amazonaws.com |
| AWS Backup | backup.AWS\$1region.amazonaws.com |
| AWS Backup Gateway | backup-gateway.AWS\$1region.amazonaws.com |
| Cópia de modelo do Amazon Bedrock | bedrock.AWS\$1region.amazonaws.com |
| SDK do Amazon Chime | chimevoiceconnector.AWS\$1region.amazonaws.com |
| AWS Clean Rooms ML | cleanrooms-ml.AWS\$1region.amazonaws.com |
| AWS CodeArtifact | codeartifact.AWS\$1region.amazonaws.com |
| CodeGuru Revisor da Amazon | codeguru-reviewer.AWS\$1region.amazonaws.com |
| Amazon Comprehend | comprehend.AWS\$1region.amazonaws.com |
| Amazon Connect | connect.AWS\$1region.amazonaws.com |
| Amazon Connect Customer Profiles | profile.AWS\$1region.amazonaws.com |
| Amazon Q no Connect | wisdom.AWS\$1region.amazonaws.com |
| AWS Database Migration Service (AWS DMS) | dms.AWS\$1region.amazonaws.com |
| AWS DeepRacer | deepracer.AWS\$1region.amazonaws.com |
| AWS Directory Service | directoryservice.AWS\$1region.amazonaws.com |
| Amazon DocumentDB | docdb-elastic.AWS\$1region.amazonaws.com |
| Amazon DynamoDB | dynamodb.AWS\$1region.amazonaws.com |
| Amazon EC2 Systems Manager (SSM) | ssm.AWS\$1region.amazonaws.com |
| Amazon Elastic Block Store (Amazon EBS) | ec2.AWS\$1region.amazonaws.com (somente EBS) |
| Amazon Elastic Container Registry (Amazon ECR) | ecr.AWS\$1region.amazonaws.com |
| Amazon Elastic File System (Amazon EFS) | elasticfilesystem.AWS\$1region.amazonaws.com |
| Amazon ElastiCache | Inclua os dois ViaService nomes no valor da chave de condição: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/kms/latest/developerguide/conditions-kms.html) |
| AWS Elemental MediaTailor | mediatailor.AWS\$1region.amazonaws.com |
| AWS Resolução de entidades | entityresolution.AWS\$1region.amazonaws.com |
| Amazon EventBridge | events.AWS\$1region.amazonaws.com |
| Amazon FinSpace | finspace.AWS\$1region.amazonaws.com |
| Amazon Forecast | forecast.AWS\$1region.amazonaws.com |
| Amazon FSx | fsx.AWS\$1region.amazonaws.com |
| AWS Glue | glue.AWS\$1region.amazonaws.com |
| AWS Ground Station | groundstation.AWS\$1region.amazonaws.com |
| Amazon GuardDuty | malware-protection.AWS\$1region.amazonaws.com |
| AWS HealthLake | healthlake.AWS\$1region.amazonaws.com |
| AWS IoT SiteWise | iotsitewise.AWS\$1region.amazonaws.com |
| Amazon Kendra | kendra.AWS\$1region.amazonaws.com |
| Amazon Keyspaces (para Apache Cassandra) | cassandra.AWS\$1region.amazonaws.com |
| Amazon Kinesis | kinesis.AWS\$1region.amazonaws.com |
| Amazon Data Firehose | firehose.AWS\$1region.amazonaws.com |
| Amazon Kinesis Video Streams | kinesisvideo.AWS\$1region.amazonaws.com |
| AWS Lambda | lambda.AWS\$1region.amazonaws.com |
| Amazon Lex | lex.AWS\$1region.amazonaws.com |
| AWS License Manager | license-manager.AWS\$1region.amazonaws.com |
| Amazon Location Service | geo.AWS\$1region.amazonaws.com |
| Amazon Lookout for Equipment | lookoutequipment.AWS\$1region.amazonaws.com |
| Amazon Lookout for Metrics | lookoutmetrics.AWS\$1region.amazonaws.com |
| Amazon Lookout for Vision | lookoutvision.AWS\$1region.amazonaws.com |
| Amazon Macie | macie.AWS\$1region.amazonaws.com |
| AWS Mainframe Modernization | m2.AWS\$1region.amazonaws.com |
| AWS Mainframe Modernization Teste de aplicativos | apptest.AWS\$1region.amazonaws.com |
| Amazon Managed Blockchain | managedblockchain.AWS\$1region.amazonaws.com |
| Amazon Managed Streaming for Apache Kafka (Amazon MSK) | kafka.AWS\$1region.amazonaws.com |
| Amazon Managed Workflows for Apache Airflow (MWAA) | airflow.AWS\$1region.amazonaws.com |
| Amazon MemoryDB | memorydb.AWS\$1region.amazonaws.com |
| Amazon Monitron | monitron.AWS\$1region.amazonaws.com |
| Amazon MQ | mq.AWS\$1region.amazonaws.com |
| Amazon Neptune | rds.AWS\$1region.amazonaws.com |
| Amazon Nimble Studio | nimble.AWS\$1region.amazonaws.com |
| AWS HealthOmics | omics.AWS\$1region.amazonaws.com |
| OpenSearch Serviço Amazon | es.AWS\$1region.amazonaws.com, aoss.AWS\$1region.amazonaws.com |
| Pacotes OpenSearch personalizados da Amazon | custom-packages.AWS\$1region.amazonaws.com |
| AWS Proton | proton.AWS\$1region.amazonaws.com |
| Amazon Quantum Ledger Database (Amazon QLDB) | qldb.AWS\$1region.amazonaws.com |
| Insights de Performance do Amazon RDS | rds.AWS\$1region.amazonaws.com |
| banco de dados de origem | redshift.AWS\$1region.amazonaws.com |
| Editor de consultas do Amazon Redshift V2 | sqlworkbench.AWS\$1region.amazonaws.com |
| Amazon Redshift Serverless | redshift-serverless.AWS\$1region.amazonaws.com |
| Amazon Rekognition | rekognition.AWS\$1region.amazonaws.com |
| Amazon Relational Database Service (Amazon RDS) | rds.AWS\$1region.amazonaws.com |
| Armazenamento de dados replicado da Amazon | ards.AWS\$1region.amazonaws.com |
| SageMaker IA da Amazon | sagemaker.AWS\$1region.amazonaws.com |
| AWS Secrets Manager | secretsmanager.AWS\$1region.amazonaws.com |
| Amazon Security Lake | securitylake.AWS\$1region.amazonaws.com |
| Amazon Simple Email Service (Amazon SES) | ses.AWS\$1region.amazonaws.com |
| Amazon Simple Notification Service (Amazon SNS) | sns.AWS\$1region.amazonaws.com |
| Amazon Simple Queue Service (Amazon SQS) | sqs.AWS\$1region.amazonaws.com |
| Amazon Simple Storage Service (Amazon S3) | s3.AWS\$1region.amazonaws.com |
| Tabelas do Amazon S3 | s3tables.AWS\$1region.amazonaws.com |
| AWS Snowball Edge | importexport.AWS\$1region.amazonaws.com |
| AWS Step Functions | states.AWS\$1region.amazonaws.com |
| AWS Storage Gateway | storagegateway.AWS\$1region.amazonaws.com |
| AWS Systems Manager Incident Manager | ssm-incidents.AWS\$1region.amazonaws.com |
| AWS Systems Manager Incident Manager Contatos | ssm-contacts.AWS\$1region.amazonaws.com |
| Amazon Timestream | timestream.AWS\$1region.amazonaws.com |
| Amazon Translate | translate.AWS\$1region.amazonaws.com |
| Acesso Verificado pela AWS | verified-access.AWS\$1region.amazonaws.com |
| Amazon WorkMail | workmail.AWS\$1region.amazonaws.com |
| Amazon WorkSpaces | workspaces.AWS\$1region.amazonaws.com |
| Amazon WorkSpaces Thin Client | thinclient.AWS\$1region.amazonaws.com |
| Amazon WorkSpaces Web | workspaces-web.AWS\$1region.amazonaws.com |
| AWS X-Ray | xray.AWS\$1region.amazonaws.com |
## kms:WrappingAlgorithm
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:WrappingAlgorithm` | String | Valor único | `GetParametersForImport` | Políticas de chaves e políticas do IAM |
Essa chave de condição controla o acesso à [GetParametersForImport](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetParametersForImport.html)operação com base no valor do [WrappingAlgorithm](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetParametersForImport.html#KMS-GetParametersForImport-request-WrappingAlgorithm)parâmetro na solicitação. Você pode usar essa condição para exigir que os principais usem determinado algoritmo para criptografar material de chaves durante o processo de importação. As solicitações para a chave pública e o token de importação exigidos falham quando especificam um algoritmo de empacotamento diferente.
A instrução de política de exemplo a seguir usa a chave de condição `kms:WrappingAlgorithm` para dar ao usuário de exemplo permissão para chamar a operação `GetParametersForImport`, mas o impede de usar o algoritmo de empacotamento `RSAES_OAEP_SHA_1`. Quando o `WrappingAlgorithm` na solicitação `GetParametersForImport` é `RSAES_OAEP_SHA_1`, a operação falha.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:GetParametersForImport",
"Resource": "*",
"Condition": {
"StringNotEquals": {
"kms:WrappingAlgorithm": "RSAES_OAEP_SHA_1"
}
}
}
```
**Consulte também**
+ [kms:ExpirationModel](#conditions-kms-expiration-model)
+ [kms:ValidTo](#conditions-kms-valid-to)
+ [kms:WrappingKeySpec](#conditions-kms-wrapping-key-spec)
## kms:WrappingKeySpec
| AWS KMS chaves de condição | Tipo de condição | Tipo de valor | Operações de API | Tipo de política |
| --- | --- | --- | --- | --- |
| `kms:WrappingKeySpec` | String | Valor único | `GetParametersForImport` | Políticas de chaves e políticas do IAM |
Essa chave de condição controla o acesso à [GetParametersForImport](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetParametersForImport.html)operação com base no valor do [WrappingKeySpec](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetParametersForImport.html#KMS-GetParametersForImport-request-WrappingKeySpec)parâmetro na solicitação. Você pode usar essa condição para exigir que as entidades principais usem determinado tipo de chave pública durante o processo de importação. Se a solicitação especifica um tipo de chave diferente, ela falha.
Como o único valor válido para o valor do parâmetro `WrappingKeySpec` é `RSA_2048`, impedir que os usuários usem esse valor efetivamente os impede de usar a operação `GetParametersForImport`.
A declaração de política de exemplo a seguir usa a chave de condição `kms:WrappingAlgorithm` para exigir que `WrappingKeySpec` na solicitação seja `RSA_4096`.
```
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/ExampleRole"
},
"Action": "kms:GetParametersForImport",
"Resource": "*",
"Condition": {
"StringEquals": {
"kms:WrappingKeySpec": "RSA_4096"
}
}
}
```
**Consulte também**
+ [kms:ExpirationModel](#conditions-kms-expiration-model)
+ [kms:ValidTo](#conditions-kms-valid-to)
+ [kms:WrappingAlgorithm](#conditions-kms-wrapping-algorithm)