Configurer les actions clés du magasin - AWS Encryption SDK
Configurez les actions clés de votre boutique

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Configurer les actions clés du magasin

Les actions du magasin de clés déterminent les opérations que vos utilisateurs peuvent effectuer et la manière dont leur AWS KMS jeu de clés hiérarchique utilise les clés KMS autorisées dans votre magasin de clés. AWS Encryption SDK prend en charge les configurations d'actions de stockage de clés suivantes.

Statique

Lorsque vous configurez votre magasin de clés de manière statique, celui-ci ne peut utiliser que la clé KMS associée à l'ARN de clé KMS que vous fournissez kmsConfiguration lors de la configuration de vos actions de magasin de clés. Une exception est déclenchée si un ARN de clé KMS différent est rencontré lors de la création, de la gestion des versions ou de l'obtention d'une clé de branche.

Vous pouvez spécifier une clé KMS multirégionale dans votrekmsConfiguration, mais l'ensemble de l'ARN de la clé, y compris la région, est conservé dans les clés de branche dérivées de la clé KMS. Vous ne pouvez pas spécifier de clé dans une autre région, vous devez fournir exactement la même clé multirégionale pour que les valeurs correspondent.

Lorsque vous configurez de manière statique les actions de votre magasin de clés, vous pouvez effectuer des opérations d'utilisation (GetActiveBranchKeyGetBranchKeyVersion,,GetBeaconKey) et des opérations administratives (CreateKeyetVersionKey). CreateKeyest une opération privilégiée qui peut ajouter un nouvel ARN de clé KMS à votre liste d'autorisations de stockage de clés. Cette clé KMS peut créer de nouvelles clés de branche actives. Nous recommandons de limiter l'accès à cette opération car une fois qu'une clé KMS est ajoutée au magasin de clés, elle ne peut pas être supprimée.

Découverte

Lorsque vous configurez les actions de votre magasin de clés pour la découverte, le magasin de clés peut utiliser n'importe quel AWS KMS key ARN autorisé dans votre magasin de clés. Toutefois, une exception est déclenchée lorsqu'une clé KMS multirégionale est détectée et que la région dans l'ARN de la clé ne correspond pas à la région du AWS KMS client utilisé.

Lorsque vous configurez votre banque de clés pour la découverte, vous ne pouvez pas effectuer d'opérations administratives telles que CreateKey etVersionKey. Vous ne pouvez effectuer que les opérations d'utilisation qui permettent de chiffrer, de déchiffrer, de signer et de vérifier. Pour de plus amples informations, veuillez consulter Implémentation des autorisations avec le moindre privilégié.

Configurez les actions clés de votre boutique

Avant de configurer les actions de votre magasin de clés, assurez-vous que les conditions préalables suivantes sont remplies.

  • Déterminez les opérations que vous devez effectuer. Pour de plus amples informations, veuillez consulter Implémentation des autorisations avec le moindre privilégié.

  • Choisissez un nom de magasin de clés logique

    Il doit y avoir un one-to-one mappage entre le nom de la table DynamoDB et le nom du magasin de clés logiques. Le nom du magasin de clés logique est lié de manière cryptographique à toutes les données stockées dans la table afin de simplifier les opérations de restauration DynamoDB. Il ne peut pas être modifié une fois défini initialement par le premier utilisateur. Vous devez toujours spécifier le même nom logique de banque de clés dans les actions de votre banque de clés. Pour de plus amples informations, veuillez consulter logical key store name.

L'exemple suivant configure de manière statique les actions du magasin de clés. Vous devez spécifier le nom de la table DynamoDB qui sert de magasin de clés, un nom logique pour le magasin de clés et l'ARN de clé KMS qui identifie une clé KMS de chiffrement symétrique.

Note

Examinez attentivement l'ARN de la clé KMS que vous spécifiez lors de la configuration statique de votre service de banque de clés. L'CreateKeyopération ajoute l'ARN de la clé KMS à la liste d'autorisation de votre magasin de clés de succursale. Une fois qu'une clé KMS est ajoutée au magasin de clés de succursale, elle ne peut pas être supprimée.

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)
}

L'exemple suivant configure les actions du magasin de clés pour la découverte. Vous devez spécifier le nom de la table DynamoDB qui sert de magasin de clés et un nom de magasin de clés logique.

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)
}