Configurar as principais ações do armazenamento - AWS Encryption SDK
Configure suas principais ações de armazenamento

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á.

Configurar as principais ações do armazenamento

As ações do armazenamento de chaves determinam quais operações seus usuários podem realizar e como seu AWS KMS chaveiro hierárquico usa as chaves KMS listadas como permitidas em seu armazenamento de chaves. O AWS Encryption SDK suporta as seguintes configurações de ações de armazenamento principais.

Estático

Quando você configura estaticamente seu armazenamento de chaves, o armazenamento de chaves só pode usar a chave KMS associada ao ARN da chave KMS que você fornece kmsConfiguration ao configurar suas ações de armazenamento de chaves. Uma exceção é lançada se um ARN de chave KMS diferente for encontrado ao criar, versionar ou obter uma chave de ramificação.

Você pode especificar uma chave KMS multirregional na suakmsConfiguration, mas todo o ARN da chave, incluindo a região, persiste nas chaves de ramificação derivadas da chave KMS. Você não pode especificar uma chave em uma região diferente. Você deve fornecer exatamente a mesma chave multirregional para que os valores correspondam.

Ao configurar estaticamente suas ações de armazenamento de chaves, você pode realizar operações de uso (GetActiveBranchKey,GetBranchKeyVersion,GetBeaconKey) e operações administrativas (CreateKeyeVersionKey). CreateKeyé uma operação privilegiada que pode adicionar um novo ARN de chave KMS à sua lista de permissões de armazenamento de chaves. Essa chave KMS pode criar novas chaves de ramificação ativas. Recomendamos limitar o acesso a essa operação porque, depois que uma chave KMS é adicionada ao armazenamento de chaves, ela não pode ser excluída.

Descoberta

Quando você configura suas ações de armazenamento de chaves para descoberta, o armazenamento de chaves pode usar qualquer AWS KMS key ARN que esteja na lista de permissões em seu armazenamento de chaves. No entanto, uma exceção é lançada quando uma chave KMS multirregional é encontrada e a região no ARN da chave não corresponde à região do AWS KMS cliente que está sendo usada.

Ao configurar seu armazenamento de chaves para descoberta, você não pode realizar operações administrativas, como CreateKey VersionKey e. Você só pode realizar as operações de uso que permitem operações de criptografia, descriptografia, assinatura e verificação. Para obter mais informações, consulte Implementação de permissões de privilégio mínimo.

Configure suas principais ações de armazenamento

Antes de configurar suas ações de armazenamento de chaves, verifique se os pré-requisitos a seguir foram atendidos.

  • Determine quais operações você precisa realizar. Para obter mais informações, consulte Implementação de permissões de privilégio mínimo.

  • Escolha um nome de armazenamento de chaves lógicas

    Deve haver um one-to-one mapeamento entre o nome da tabela do DynamoDB e o nome do armazenamento de chaves lógicas. O nome do armazenamento lógico de chaves é vinculado criptograficamente a todos os dados armazenados na tabela para simplificar as operações de restauração do DynamoDB. Ele não pode ser alterado depois de definido inicialmente pelo primeiro usuário. Você deve sempre especificar o mesmo nome lógico de armazenamento de chaves em suas ações de armazenamento de chaves. Para obter mais informações, consulte logical key store name.

O exemplo a seguir configura estaticamente as principais ações do armazenamento. Você deve especificar o nome da tabela do DynamoDB que serve como seu armazenamento de chaves, um nome lógico para o armazenamento de chaves e o ARN da chave KMS que identifica uma chave KMS de criptografia simétrica.

nota

Considere cuidadosamente o ARN da chave KMS que você especifica ao configurar estaticamente seu serviço de armazenamento de chaves. A CreateKey operação adiciona o ARN da chave KMS à sua lista de permissões do armazenamento de chaves da filial. Depois que uma chave KMS é adicionada ao armazenamento de chaves da filial, ela não pode ser excluída.

Java
final KeyStore keystore = KeyStore.builder().KeyStoreConfig(
	                 KeyStoreConfig.builder()
	                         .ddbClient(DynamoDbClient.create())
	                         .ddbTableName(keyStoreName)
	                         .logicalKeyStoreName(logicalKeyStoreName)
	                         .kmsClient(KmsClient.create())
	                         .kmsConfiguration(KMSConfiguration.builder()
	                                 .kmsKeyArn(kmsKeyArn)
	                                 .build())
	                         .build()).build();
C# / .NET
var kmsConfig = new KMSConfiguration { KmsKeyArn = kmsKeyArn };
	 var keystoreConfig = new KeyStoreConfig
	 {
	     KmsClient = new AmazonKeyManagementServiceClient(),
	     KmsConfiguration = kmsConfig,
	     DdbTableName = keyStoreName,
	     DdbClient = new AmazonDynamoDBClient(),
	     LogicalKeyStoreName = logicalKeyStoreName
	 };
	 var keystore = new KeyStore(keystoreConfig);
Python
keystore: KeyStore = KeyStore(
    config=KeyStoreConfig(
        ddb_client=ddb_client,
        ddb_table_name=key_store_name,
        logical_key_store_name=logical_key_store_name,
        kms_client=kms_client,
        kms_configuration=KMSConfigurationKmsKeyArn(
            value=kms_key_id
        ),
    )
)
Rust
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let key_store_config = KeyStoreConfig::builder()
    .kms_client(aws_sdk_kms::Client::new(&sdk_config))
    .ddb_client(aws_sdk_dynamodb::Client::new(&sdk_config))
    .ddb_table_name(key_store_name)
    .logical_key_store_name(logical_key_store_name)
    .kms_configuration(KmsConfiguration::KmsKeyArn(kms_key_arn.to_string()))
    .build()?;

let keystore = keystore_client::Client::from_conf(key_store_config)?;
Go
import (
	keystore "github.com/aws/aws-cryptographic-material-providers-library/mpl/awscryptographykeystoresmithygenerated"
	keystoretypes "github.com/aws/aws-cryptographic-material-providers-library/mpl/awscryptographykeystoresmithygeneratedtypes"
)

kmsConfig := keystoretypes.KMSConfigurationMemberkmsKeyArn{
    Value: kmsKeyArn,
}
keyStore, err := keystore.NewClient(keystoretypes.KeyStoreConfig{
    DdbTableName:        keyStoreTableName,
    KmsConfiguration:    &kmsConfig,
    LogicalKeyStoreName: logicalKeyStoreName,
    DdbClient:           ddbClient,
    KmsClient:           kmsClient,
})
if err != nil {
    panic(err)
}

O exemplo a seguir configura as principais ações de armazenamento para descoberta. Você deve especificar o nome da tabela do DynamoDB que serve como seu armazenamento de chaves e um nome lógico de armazenamento de chaves.

Java
final KeyStore keystore = KeyStore.builder().KeyStoreConfig(
                 KeyStoreConfig.builder()
                         .ddbClient(DynamoDbClient.create())
                         .ddbTableName(keyStoreName)
                         .logicalKeyStoreName(logicalKeyStoreName)
                         .kmsClient(KmsClient.create())
                         .kmsConfiguration(KMSConfiguration.builder()
                                 .discovery(Discovery.builder().build())
                                 .build())
                         .build()).build();
C# / .NET
var keystoreConfig = new KeyStoreConfig
 {
     KmsClient = new AmazonKeyManagementServiceClient(),
     KmsConfiguration = new KMSConfiguration {Discovery = new Discovery()},
     DdbTableName = keyStoreName,
     DdbClient = new AmazonDynamoDBClient(),
     LogicalKeyStoreName = logicalKeyStoreName
 };
 var keystore = new KeyStore(keystoreConfig);
Python
keystore: KeyStore = KeyStore(
    config=KeyStoreConfig(
        ddb_client=ddb_client,
        ddb_table_name=key_store_name,
        logical_key_store_name=logical_key_store_name,
        kms_client=kms_client,
        kms_configuration=KMSConfigurationDiscovery(
            value=Discovery()
        ),
    )
)
Rust
let key_store_config = KeyStoreConfig::builder()
        .kms_client(kms_client)
        .ddb_client(ddb_client)
        .ddb_table_name(key_store_name)
        .logical_key_store_name(logical_key_store_name)
        .kms_configuration(KmsConfiguration::Discovery(Discovery::builder().build()?))
        .build()?;
Go
import (
	keystore "github.com/aws/aws-cryptographic-material-providers-library/mpl/awscryptographykeystoresmithygenerated"
	keystoretypes "github.com/aws/aws-cryptographic-material-providers-library/mpl/awscryptographykeystoresmithygeneratedtypes"
)

kmsConfig := keystoretypes.KMSConfigurationMemberdiscovery{}
keyStore, err := keystore.NewClient(keystoretypes.KeyStoreConfig{
    DdbTableName:        keyStoreName,
    KmsConfiguration:    &kmsConfig,
    LogicalKeyStoreName: logicalKeyStoreName,
    DdbClient:           ddbClient,
    KmsClient:           kmsClient,
})
if err != nil {
    panic(err)
}