翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
AWS Database Encryption SDK は*、キーリング*を使用して[エンベロープ暗号化](concepts.md#envelope-encryption)を実行します。データキーの生成、暗号化、復号は、キーリングによって行われます。キーリングは、暗号化された各レコードを保護する一意のデータキーのソースと、そのデータキーを暗号化する[ラッピングキー](concepts.md#wrapping-key)を決定します。キーリングは暗号化時に指定し、復号時には同じキーリングか別のキーリングを指定します。
各キーリングを個別に使用するか、キーリングを組み合わせて[マルチキーリング](use-multi-keyring.md)にすることができます。ほとんどのキーリングではデータキーを生成、暗号化、および復号することができますが、特定のオペレーションを 1 つのみ実行するキーリング (例: データキーのみを生成するキーリング) を作成し、他のキーリングと組み合わせて使用することができます。
ラッピングキーを保護し、 [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS) を暗号化しないままに AWS KMS keys しない を使用するキーリングなど、安全な境界内で暗号化オペレーションを実行する AWS KMS キーリングを使用することをお勧めします。また、ハードウェアセキュリティモジュール (HSM) に保存されているラッピングキーや他のマスターキーサービスによって保護されているラッピングキーを使用するキーリングを作成することもできます。
キーリングは、データキー、そして最終的にはデータを保護するラッピングキーを決定します。タスクに実用的で、最も安全なラッピングキーを使用してください。可能な場合は常に、ハードウェアセキュリティモジュール (HSM) またはキー管理インフラストラクチャ ([AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS) の KMS キーや [AWS CloudHSM](https://docs.aws.amazon.com/cloudhsm/latest/userguide/) の暗号化キーなど) によって保護されたラッピングキーを使用してください。
AWS Database Encryption SDK には複数のキーリングとキーリング設定が用意されており、独自のカスタムキーリングを作成できます。同じタイプまたは異なるタイプの 1 つ以上のキーリングを含む[マルチキーリング](use-multi-keyring.md)を作成することもできます。
**Topics**
+ [キーリングのしくみ](#using-keyrings)
+ [AWS KMS キーリング](use-kms-keyring.md)
+ [AWS KMS 階層キーリング](use-hierarchical-keyring.md)
+ [AWS KMS ECDH キーリング](use-kms-ecdh-keyring.md)
+ [Raw AES キーリング](use-raw-aes-keyring.md)
+ [Raw RSA キーリング](use-raw-rsa-keyring.md)
+ [Raw ECDH キーリング](use-raw-ecdh-keyring.md)
+ [マルチキーリング](use-multi-keyring.md)
## キーリングのしくみ
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
データベース内のフィールドを暗号化して署名すると、 AWS Database Encryption SDK はキーリングに暗号化マテリアルを要求します。キーリングは、プレーンテキストのデータキー、キーリング内の各ラッピングキーによって暗号化されたデータキーのコピー、およびデータキーに関連付けられた MAC キーを返します。 AWS Database Encryption SDK は、プレーンテキストキーを使用してデータを暗号化し、できるだけ早くプレーンテキストのデータキーをメモリから削除します。その後、 AWS Database Encryption SDK は、暗号化されたデータキーと、暗号化や署名の指示などの他の情報を含む[マテリアルの説明](concepts.md#material-description)を追加します。 AWS Database Encryption SDK は MAC キーを使用して、マテリアルの説明と `ENCRYPT_AND_SIGN`または とマークされたすべてのフィールドの正規化に関するハッシュベースのメッセージ認証コード (HMACs) を計算します`SIGN_ONLY`。
データを復号する際には、データの暗号化に使用したのと同じキーリングを使用することも、別のキーリングを使用することもできます。データを復号するには、復号キーリングが暗号化キーリング内の少なくとも 1 つのラッピングキーにアクセスできる必要があります。
AWS Database Encryption SDK は、暗号化されたデータキーをマテリアルの説明からキーリングに渡し、キーリングのいずれかを復号するよう求めます。キーリングは、ラッピングキーを使用して暗号化されたデータキーのいずれかを復号し、プレーンテキストのデータキーを返します。 AWS Database Encryption SDK は、プレーンテキストデータキーを使用してデータを復号します。キーリングのラッピングキーのいずれも暗号化されたデータキーを復号できない場合は、復号は失敗します。
単一のキーリングを使用するか、同じタイプまたは異なるタイプのキーリングを組み合わせて[マルチキーリング](use-multi-keyring.md)にすることもできます。データを暗号化すると、マルチキーリングは、マルチキーリングを構成するすべてのキーリング内のすべてのラッピングキーによって暗号化されたデータキーのコピーと、そのデータキーに関連付けられた MAC キーを返します。データは、マルチキーリングのラッピングキーのいずれかを持つキーリングを使用して復号できます。
# AWS KMS キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
AWS KMS キーリングは、対称暗号化または非対称 RSA [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)を使用してデータキーを生成、暗号化、復号します。 AWS Key Management Service (AWS KMS) は KMS キーを保護し、FIPS 境界内で暗号化オペレーションを実行します。可能な限り、 AWS KMS キーリング、または同様のセキュリティプロパティを持つキーリングを使用することをお勧めします。
キーリングで対称マルチリージョン KMS AWS KMS キーを使用することもできます。マルチリージョンを使用した詳細と例については AWS KMS keys、「」を参照してください[マルチリージョンの使用 AWS KMS keys](#config-mrks)。マルチリージョンキーの詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[マルチリージョンキーを使用する](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)」を参照してください。
AWS KMS キーリングには、次の 2 種類のラッピングキーを含めることができます。
+ **ジェネレーターキー**: プレーンテキストのデータキーを生成し、暗号化します。データを暗号化するキーリングには、ジェネレーターキーが 1 つ必要です。
+ **追加キー**: ジェネレーターキーが生成したプレーンテキストのデータキーを暗号化します。 AWS KMS キーリングには 0 個以上の追加キーを含めることができます。
レコードを暗号化するにはジェネレーターキーが必要です。 AWS KMS キーリングに AWS KMS キーが 1 つしかない場合、そのキーはデータキーの生成と暗号化に使用されます。
すべてのキーリングと同様に、 AWS KMS キーリングは個別に使用することも、同じタイプまたは異なるタイプの他のキー[リングを持つマルチキー](use-multi-keyring.md)リングでも使用できます。
**Topics**
+ [AWS KMS キーリングに必要なアクセス許可](#kms-keyring-permissions)
+ [AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)
+ [AWS KMS キーリングの作成](#kms-keyring-create)
+ [マルチリージョンの使用 AWS KMS keys](#config-mrks)
+ [AWS KMS 検出キーリングの使用](#kms-keyring-discovery)
+ [AWS KMS リージョン検出キーリングの使用](#kms-keyring-regional)
## AWS KMS キーリングに必要なアクセス許可
AWS Database Encryption SDK は を必要とせず AWS アカウント 、 に依存しません AWS のサービス。ただし、 AWS KMS キーリングを使用するには、 AWS アカウント と、キーリング AWS KMS keys の に対する以下の最小限のアクセス許可が必要です。
+ AWS KMS キーリングで暗号化するには、ジェネレーターキーに対する [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) アクセス許可が必要です。 AWS KMS キーリングのすべての追加キーに対する [kms:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) アクセス許可が必要です。
+ AWS KMS キーリングで復号するには、 AWS KMS キーリング内の少なくとも 1 つのキーに対する [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) アクセス許可が必要です。
+ AWS KMS キーリングで構成されるマルチキーリングで暗号化するには、ジェネレーターキーリングのジェネレーターキーに対する [kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) アクセス許可が必要です。他のすべてのキーリングの他のすべての AWS KMS キーに対する [kms:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) アクセス許可が必要です。
+ 非対称 RSA AWS KMS キーリングで暗号化するには、キーリングの作成時に暗号化に使用するパブリックキーマテリアルを指定する必要があるため、[kms:GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) または [kms:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) は必要ありません。このキーリングで暗号化する場合、 AWS KMS 呼び出しは行われません。非対称 RSA AWS KMS キーリングで復号するには、[kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) アクセス許可が必要です。
のアクセス許可の詳細については AWS KMS keys、「 *AWS Key Management Service デベロッパーガイド*」の[「認証とアクセスコントロール](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html)」を参照してください。
## AWS KMS キーリング AWS KMS keys での の識別
AWS KMS キーリングには 1 つ以上の を含めることができます AWS KMS keys。 AWS KMS キーリングで を指定する AWS KMS key には、サポートされている AWS KMS キー識別子を使用します。キーリング AWS KMS key 内の を識別するために使用できるキー識別子は、 オペレーションと言語の実装によって異なります。 AWS KMS keyのキー識別子の詳細については、*AWS Key Management Service デベロッパーガイド*の「[キー識別子](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id)」を参照してください。
ベストプラクティスとして、自らのタスクにとって実用的である最も具体的なキー識別子を使用します。
+ AWS KMS キーリングで暗号化するには、[キー ID](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id)、[キー ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN)、[エイリアス名](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name)、または[エイリアス ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN) を使用してデータを暗号化できます。
**注記**
暗号化キーリングで KMS キーのエイリアス名またはエイリアス ARN を指定すると、暗号化オペレーションによって、現在エイリアスに関連付けられているキー ARN が、暗号化されたデータキーのメタデータに保存されます。エイリアスは保存されません。エイリアスの変更は、暗号化されたデータキーの復号に使用される KMS キーには影響しません。
+ AWS KMS キーリングで復号するには、キー ARN を使用して を識別する必要があります AWS KMS keys。詳細については、「[ラッピングキーの選択](configure.md#config-keys)」を参照してください。
+ 暗号化および復号に使用するキーリングでは、キー ARN を使用して AWS KMS keysを指定する必要があります。
復号時に、 AWS Database Encryption SDK は、暗号化されたデータ AWS KMS キーの 1 つを復号 AWS KMS key できる のキーリングを検索します。具体的には、 AWS Database Encryption SDK は、マテリアルの説明で暗号化されたデータキーごとに次のパターンを使用します。
+ AWS Database Encryption SDK は、マテリアル説明のメタデータからデータキーを暗号化 AWS KMS key した のキー ARN を取得します。
+ AWS Database Encryption SDK は、キー ARN AWS KMS key が一致する の復号キーリングを検索します。
+ キーリングで一致するキー ARN AWS KMS key を持つ が見つかった場合、 AWS Database Encryption SDK は KMS キーを使用して暗号化されたデータキーを復号するように AWS KMS に要求します。
+ それ以外の場合は、暗号化された次のデータキーに進みます (ある場合)。
## AWS KMS キーリングの作成
各 AWS KMS キーリングは、同じ AWS KMS key または異なる AWS アカウント および AWS KMS keys の 1 つまたは複数の で設定できます AWS リージョン。 AWS KMS key は、対称暗号化キー (`SYMMETRIC_DEFAULT`) または非対称 RSA KMS キーである必要があります。対称暗号化[マルチリージョン KMS キー](#config-mrks)を使用することもできます。マルチ AWS KMS キーリングでは、1 つ以上のキーリングを使用できます。 [マルチキーリング](use-multi-keyring.md)
データを暗号化および復号する AWS KMS キーリングを作成することも、暗号化または復号専用の AWS KMS キーリングを作成することもできます。データを暗号化する AWS KMS キーリングを作成するときは、ジェネレーター*キー*を指定する必要があります。ジェネレーターキー AWS KMS key は、プレーンテキストのデータキーを生成して暗号化するために使用される です。データキーは数学的には KMS キーとは無関係です。次に、選択した場合は、同じプレーンテキストのデータキーを暗号化 AWS KMS keys する追加の を指定できます。このキーリングで保護された暗号化されたフィールドを復号するには、使用する復号キーリングに、キーリングで AWS KMS keys 定義された の少なくとも 1 つが含まれているか、含まれていない必要があります AWS KMS keys。( を使用しない AWS KMS キーリング AWS KMS keys は、[AWS KMS 検出キーリング](#kms-keyring-discovery)と呼ばれます）。
暗号化キーリングまたはマルチキーリング内のすべてのラッピングキーは、データキーを暗号化できる必要があります。いずれかのラッピングキーが暗号化に失敗すると、暗号化メソッドは失敗します。そのため、呼び出し元は、キーリング内のすべてのキーについて[必要な許可](#kms-keyring-permissions)を持っている必要があります。検出キーリングを使用して、単独またはマルチキーリングでデータを暗号化すると、暗号化操作は失敗します。
次の例では、 `CreateAwsKmsMrkMultiKeyring`メソッドを使用して、対称暗号化 KMS AWS KMS キーを持つ キーリングを作成します。`CreateAwsKmsMrkMultiKeyring` メソッドは自動的に AWS KMS クライアントを作成し、キーリングが単一リージョンキーとマルチリージョンキーの両方を正しく処理するようにします。これらの例では、[キー ARNs](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) を使用して KMS キーを識別します。詳細については、「[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)」を参照してください。
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = kmsKeyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_mrk_multi_keyring()
.generator(kms_key_id)
.send()
.await?;
```
------
次の例では、 `CreateAwsKmsRsaKeyring`メソッドを使用して、非対称 RSA KMS AWS KMS キーを持つ キーリングを作成します。非対称 RSA AWS KMS キーリングを作成するには、次の値を指定します。
+ `kmsClient`: 新しい AWS KMS クライアントを作成する
+ `kmsKeyID`: 非対称 RSA KMS キーを識別するキー ARN
+ `publicKey`: 渡したキーのパブリックキーを表す UTF-8 エンコードされた PEM ファイルの ByteBuffer `kmsKeyID`
+ `encryptionAlgorithm`: 暗号化アルゴリズムは `RSAES_OAEP_SHA_256`または である必要があります `RSAES_OAEP_SHA_1`
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
CreateAwsKmsRsaKeyringInput.builder()
.kmsClient(KmsClient.create())
.kmsKeyId(rsaKMSKeyArn)
.publicKey(publicKey)
.encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
.build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsRsaKeyringInput = new CreateAwsKmsRsaKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = rsaKMSKeyArn,
PublicKey = publicKey,
EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_rsa_keyring = mpl
.create_aws_kms_rsa_keyring()
.kms_key_id(rsa_kms_key_arn)
.public_key(public_key)
.encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
.kms_client(aws_sdk_kms::Client::new(&sdk_config))
.send()
.await?;
```
------
## マルチリージョンの使用 AWS KMS keys
マルチリージョンを AWS Database Encryption SDK のラッピングキー AWS KMS keys として使用できます。1 つの でマルチリージョンキーを使用して暗号化する場合 AWS リージョン、別の で関連するマルチリージョンキーを使用して復号できます AWS リージョン。
マルチリージョン KMS キーは、同じキーマテリアルとキー ID AWS リージョン を持つ異なる AWS KMS keys の のセットです。これらの*関連*キーは、さまざまなリージョンで同じキーであるかのように使用できます。マルチリージョンキーは、クロスリージョン呼び出しを行うことなく、あるリージョンで暗号化し、別のリージョンで復号する必要がある一般的なディザスタリカバリおよびバックアップシナリオをサポートします AWS KMS。マルチリージョンキーの詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[マルチリージョンキーを使用する](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)」を参照してください。
マルチリージョンキーをサポートするために、 AWS Database Encryption SDK には AWS KMS multi-Region-awareキーリングが含まれています。`CreateAwsKmsMrkMultiKeyring` メソッドは、単一リージョンキーとマルチリージョンキーの両方をサポートします。
+ 単一リージョンキーの場合、マルチリージョン対応シンボルは、単一リージョン AWS KMS キーリングのように動作します。データを暗号化した単一リージョンキーを使用してのみ、暗号化テキストの復号が試されます。 AWS KMS キーリングエクスペリエンスを簡素化するには、対称暗号化 KMS キーを使用するたびに `CreateAwsKmsMrkMultiKeyring`メソッドを使用することをお勧めします。
+ マルチリージョンキーの場合、マルチリージョン対応シンボルは、データを暗号化したのと同じマルチリージョンキー、または指定したリージョン内の関連するマルチリージョンキーを使用して暗号文の復号を試みます。
複数の KMS キーを使用するマルチリージョン対応キーリングでは、複数の単一リージョンキーとマルチリージョンキーを指定できます。ただし、関連するマルチリージョンキーのセットごとに 1 つのキーしか指定できません。同じキー ID で複数のキー識別子を指定すると、コンストラクタの呼び出しは失敗します。
次の例では、マルチリージョン KMS AWS KMS キーを使用して キーリングを作成します。この例では、ジェネレーターキーとしてマルチリージョンキーを指定し、子キーとして単一リージョンキーを指定します。
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput =
CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(multiRegionKeyArn)
.kmsKeyIds(Collections.singletonList(kmsKeyArn))
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = multiRegionKeyArn,
KmsKeyIds = new List { kmsKeyArn }
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(multiRegion_key_arn)
.kms_key_ids(vec![key_arn.to_string()])
.send()
.await?;
```
------
マルチリージョン AWS KMS キーリングを使用すると、暗号文を strict モードまたは discover モードで復号できます。厳格モードで暗号文を復号するには、暗号文を復号するリージョン内の関連するマルチリージョンキーのキー ARN を使用してマルチリージョン対応シンボルをインスタンス化します。別のリージョン (例: レコードが暗号化されたリージョン) で関連するマルチリージョンキーのキー ARN を指定した場合、マルチリージョン対応シンボルは、その AWS KMS keyのクロスリージョン呼び出しを実行します。
Strict モードで復号する場合、マルチリージョン対応シンボルにはキー ARN が必要です。関連するマルチリージョンキーの各セットからキー ARN を 1 つだけ受け付けます。
AWS KMS マルチリージョンのキーを使用して、検出モードで復号することもできます。検出モードで復号する場合は、 AWS KMS keysを指定しません。(単一リージョン AWS KMS の検出キーリングの詳細については、「」を参照してください[AWS KMS 検出キーリングの使用](#kms-keyring-discovery)。)
マルチリージョンキーで暗号化した場合、検出モードのマルチリージョン対応シンボルは、ローカルリージョン内の関連するマルチリージョンキーを使用して復号しようとします。何も存在しない場合、呼び出しは失敗します。検出モードでは、 AWS Database Encryption SDK は暗号化に使用されるマルチリージョンキーのクロスリージョン呼び出しを試みません。
## AWS KMS 検出キーリングの使用
復号するときは、 AWS Database Encryption SDK が使用できるラッピングキーを指定することがベストプラクティスです。このベストプラクティスに従うには、ラ AWS KMS ッピングキーを AWS KMS 指定したキーに制限する復号キーリングを使用します。ただし、*AWS KMS 検出キーリング*、つまりラッピングキーを指定しない AWS KMS キーリングを作成することもできます。
AWS Database Encryption SDK は、標準の AWS KMS 検出キーリングと AWS KMS マルチリージョンキー用の検出キーリングを提供します。 AWS Database Encryption SDK でのマルチリージョンキーの使用については、「[マルチリージョンの使用 AWS KMS keys](#config-mrks)」を参照してください。
ラッピングキーが指定されていないため、検出キーリングはデータを暗号化できません。検出キーリングを使用して、単独またはマルチキーリングでデータを暗号化すると、暗号化操作は失敗します。
復号時に、検出キーリングを使用すると、 AWS Database Encryption SDK は、暗号化されたデータキーを所有またはアクセスできるユーザーに関係なく、暗号化されたデータキーを暗号化 AWS KMS key された を使用して復号するように AWS KMS に要求できます AWS KMS key。呼び出しは、呼び出し元にその AWS KMS keyに対する `kms:Decrypt` 許可がある場合にのみ成功します。
**重要**
復号マルチキーリングに AWS KMS 検出[キーリング](use-multi-keyring.md)を含めると、検出キーリングはマルチキーリングの他のキーリングで指定されたすべての KMS キー制限を上書きします。マルチキーリングは、最も制限の少ないキーリングのように動作します。検出キーリングを単独または複数のキーリングで使用してデータを暗号化すると、暗号化オペレーションは失敗します
AWS Database Encryption SDK は、便利な AWS KMS 検出キーリングを提供します。ただし、次の理由から、可能な限り制限されたキーリングを使用することをお勧めします。
+ **真正性** – AWS KMS 検出キーリングは、呼び出し元 AWS KMS key に復号化に使用するアクセス許可がある限り、マテリアル説明のデータキーの暗号化に使用された任意の AWS KMS key を使用できます。これは、発信者 AWS KMS key が使用する ではない場合があります。たとえば、暗号化されたデータキーの 1 つが、誰でも使用できる安全性 AWS KMS key の低い で暗号化されている可能性があります。
+ **レイテンシーとパフォーマンス** – AWS Database AWS KMS Encryption SDK は、他の AWS アカウント およびリージョン AWS KMS keys の によって暗号化されたデータキーを含む、暗号化されたすべてのデータキーを復号しようとし、呼び出し元 AWS KMS keys に復号に使用するアクセス許可がないため、検出キーリングは他のキーリングよりもかなり遅くなる可能性があります。
検出キーリングを使用する場合は、[*検出フィルター*](configure.md#config-discovery)を使用して、指定 AWS アカウント および[パーティション](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)で使用できる KMS キーを制限することをお勧めします。アカウント ID とパーティションの検索については、の[AWS アカウント 「識別子と ARN 形式](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html)」を参照してください*AWS 全般のリファレンス*。 [https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax)
次のコード例では、 AWS Database Encryption SDK が使用できる KMS AWS KMS キーを`aws`パーティションと`111122223333`サンプルアカウントのキーに制限する検出フィルターを使用して、検出キーリングをインスタンス化します。
このコードを使用する前に、例 AWS アカウント とパーティションの値を AWS アカウント および パーティションの有効な値に置き換えます。KMS キーが中国リージョンにある場合は、`aws-cn` のパーティションの値を使用します。KMS キーが AWS GovCloud (US) Regionsにある場合は、`aws-us-gov` のパーティションの値を使用します。他のすべての AWS リージョンについては、`aws` のパーティションの値を使用します。
------
#### [ Java ]
```
// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
## AWS KMS リージョン検出キーリングの使用
AWS KMS リージョンレベルの検出キーリングは、KMS キーの ARN を指定しないキーリングです。代わりに、 AWS Database Encryption SDK は、特に KMS キーのみを使用して復号化できます AWS リージョン。
AWS KMS リージョン検出キーリングを使用して復号する場合、 AWS Database Encryption SDK は、指定された AWS KMS key の で暗号化された暗号化されたデータキーを復号します AWS リージョン。成功するには、発信者がデータキーを暗号化 AWS リージョン した指定された AWS KMS keys 内の少なくとも 1 つの に対する`kms:Decrypt`アクセス許可を持っている必要があります。
他の検出キーリングと同様、リージョンレベルの検出キーリングは暗号化には影響しません。暗号化されたフィールドを復号する場合にのみ機能します。暗号化と復号に使用されるマルチキーリングでリージョンレベルの検出キーリングを使用する場合、それは復号時にのみ有効です。マルチリージョン検出キーリングを単独または複数のキーリングで使用してデータを暗号化すると、暗号化オペレーションは失敗します。
**重要**
復号マルチキーリングに AWS KMS リージョン検出[キーリング](use-multi-keyring.md)を含めると、リージョン検出キーリングは、マルチキーリングの他のキーリングで指定されたすべての KMS キー制限を上書きします。マルチキーリングは、最も制限の少ないキーリングのように動作します。 AWS KMS 検出キーリングは、単独で使用する場合も、マルチキーリングで使用する場合も、暗号化には影響しません。
AWS Database Encryption SDK のリージョン検出キーリングは、指定されたリージョンの KMS キーでのみ復号を試みます。検出キーリングを使用する場合は、 AWS KMS クライアントでリージョンを設定します。これらの AWS Database Encryption SDK 実装では、リージョンごとに KMS キーをフィルタリングしませんが、指定されたリージョン外の KMS キーの復号リクエストは失敗 AWS KMS します。
検出キーリングを使用する場合は、*検出フィルター*を使用して、復号に使用される KMS キーを、指定された AWS アカウント および パーティション内のキーに制限することをお勧めします。
たとえば、次のコードは、検出フィルターを使用して AWS KMS リージョン検出キーリングを作成します。このキーリングは、 AWS Database Encryption SDK を米国西部 (オレゴン) リージョン (us-west-2) のアカウント 111122223333 の KMS キーに制限します。
------
#### [ Java ]
```
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.regions("us-west-2")
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter,
Regions = us-west-2
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.regions(us-west-2)
.send()
.await?;
```
------
# AWS KMS 階層キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
**注記**
2023 年 7 月 24 日の時点では、デベロッパープレビュー中に作成されたブランチキーはサポートされていません。新しいブランチキーを作成して、デベロッパープレビュー中に作成したキーストアを引き続き使用します。
AWS KMS 階層キーリングを使用すると、レコードを暗号化または復号する AWS KMS たびに を呼び出すことなく、対称暗号化 KMS キーで暗号化マテリアルを保護できます。これは、 への呼び出しを最小限に抑える必要があるアプリケーションや AWS KMS、セキュリティ要件に違反することなく一部の暗号化マテリアルを再利用できるアプリケーションに適しています。
階層キーリングは、Amazon DynamoDB テーブルに保持されている AWS KMS 保護された*ブランチキー*を使用し、暗号化および復号オペレーションで使用されるブランチキーマテリアルをローカルにキャッシュすることで AWS KMS 、呼び出しの数を減らす暗号化マテリアルキャッシュソリューションです。DynamoDB テーブルは、ブランチキーを管理および保護するキーストアとして機能します。アクティブなブランチキーと、ブランチキーの以前のすべてのバージョンが格納されます。アクティブなブランチキーは、ブランチキーの最新バージョンです。階層キーリングは、暗号化リクエストごとに一意のデータ暗号化キーを使用し、アクティブなブランチキーから派生した一意のラッピングキーを使用して各データ暗号化キーを暗号化します。階層キーリングは、アクティブなブランチキーと、その導出ラッピングキーの間に確立された階層に依拠します。
階層キーリングは通常、複数のリクエストを満たすために各ブランチキーバージョンを使用します。ただし、ユーザーがアクティブなブランチキーを再利用する範囲を制御し、アクティブなブランチキーをローテーションする頻度を決定します。ブランチキーのアクティブなバージョンは、ローテーションされるまでアクティブなままとなります。アクティブなブランチキーの以前のバージョンは暗号化オペレーションの実行には使用されませんが、引き続きクエリを実行して復号オペレーションに使用できます。
階層キーリングをインスタンス化すると、ローカルキャッシュが作成されます。ブランチキーマテリアルがローカルキャッシュ内に格納される最大時間 (ブランチキーマテリアルが期限切れになってキャッシュから削除されるまでの時間) を定義する[キャッシュ制限](#cache-limit)を指定します。階層キーリングは 1 回の AWS KMS 呼び出しでブランチキーを復号し、 オペレーションで `branch-key-id`が初めて指定されたときにブランチキーマテリアルをアセンブルします。その後、ブランチキーマテリアルはローカルキャッシュに格納され、キャッシュ制限が期限切れになるまで、その `branch-key-id` を指定するすべての暗号化および復号オペレーションのために再利用されます。ブランチキーマテリアルをローカルキャッシュに保存することで、 AWS KMS 呼び出しが減ります。例えば、キャッシュ制限が 15 分である場合を考えてみましょう。そのキャッシュ制限内で 10,000 回の暗号化オペレーションを実行する場合、[従来の AWS KMS キーリング](use-kms-keyring.md)は 10,000 回の暗号化オペレーションを満たすために 10,000 回の AWS KMS 呼び出しを行う必要があります。アクティブな が 1 つある場合`branch-key-id`、階層キーリングは 10,000 回の暗号化オペレーションを満たすために 1 回の AWS KMS 呼び出しを行うだけで済みます。
ローカルキャッシュは、暗号化マテリアルと復号マテリアルを分離します。暗号化マテリアルはアクティブなブランチキーからアセンブルされ、キャッシュ制限の有効期限が切れるまですべての暗号化オペレーションに再利用されます。復号マテリアルは、暗号化されたフィールドのメタデータで識別されるブランチキー ID とバージョンからアセンブルされ、キャッシュ制限の有効期限が切れるまで、ブランチキー ID とバージョンに関連するすべての復号オペレーションに再利用されます。ローカルキャッシュは、一度に同じブランチキーの複数のバージョンを保存できます。ローカルキャッシュが を使用するように設定されている場合[branch key ID supplier](#branch-key-id-supplier)、一度に複数のアクティブなブランチキーからのブランチキーマテリアルを保存することもできます。
**注記**
AWS Database Encryption SDK の*階層キーリング*に関するすべての言及は、 AWS KMS 階層キーリングを参照しています。
**Topics**
+ [仕組み](#how-hierarchical-keyring-works)
+ [前提条件](#hierarchical-keyring-prereqs)
+ [必要なアクセス許可](#hierarchical-keyring-permissions)
+ [キャッシュを選択する](#hierarchical-keyring-caches)
+ [階層キーリングを作成する](#initialize-hierarchical-keyring)
+ [検索可能な暗号化のための階層キーリングの使用](#searchable-encryption-hierarchical-keyrings)
## 仕組み
次のチュートリアルでは、階層キーリングが暗号化および復号マテリアルをアセンブルする方法と、暗号化および復号オペレーションのためにキーリングが実行するさまざまな呼び出しについて説明します。ラッピングキーの導出とプレーンテキストデータキーの暗号化プロセスの技術的な詳細については、「[AWS KMS 階層キーリングの技術的な詳細](reference.md#hierarchical-keyring-details)」を参照してください。
**暗号化および署名**
次のチュートリアルでは、階層キーリングが暗号化マテリアルをアセンブルし、一意のラッピングキーを導出する方法について説明します。
1. 暗号化メソッドは、階層キーリングに暗号化マテリアルを要求します。キーリングはプレーンテキストのデータキーを生成し、ローカルキャッシュにラッピングキーを生成する有効なブランチキーマテリアルがあるかどうかをチェックします。有効なブランチキーマテリアルがある場合、キーリングは**ステップ 4 **に進みます。
1. 有効なブランチキーマテリアルがない場合、階層キーリングはキーストアにアクティブなブランチキーをクエリします。
1. キーストアは AWS KMS を呼び出してアクティブなブランチキーを復号し、プレーンテキストのアクティブなブランチキーを返します。アクティブなブランチキーを識別するデータは、 AWS KMSに対する復号呼び出しで追加認証データ (AAD) を提供するためにシリアル化されます。
1. キーストアは、プレーンテキストのブランチキーと、ブランチキーのバージョンなど、それを識別するデータを返します。
1. 階層キーリングはブランチキーマテリアル (プレーンテキストブランチキーとブランチキーバージョン) をアセンブルし、それらのコピーをローカルキャッシュに格納します。
1. 階層キーリングは、プレーンテキストブランチキーと 16 バイトのランダムソルトから一意のラッピングキーを導出します。プレーンテキストデータキーのコピーを暗号化するために、導出されたラッピングキーを使用します。
暗号化メソッドは、暗号化マテリアルを使用してレコードを暗号化して署名します。 AWS Database Encryption SDK でレコードがどのように暗号化および署名されるのかに関する詳細については、「[暗号化して署名](how-it-works.md#encrypt-and-sign)」を参照してください。
**復号および検証**
次のチュートリアルでは、階層キーリングが復号マテリアルをアセンブルし、暗号化されたデータキーを復号する方法について説明します。
1. 復号メソッドは、暗号化されたレコードのマテリアルの説明フィールドから暗号化されたデータキーを識別し、それを階層キーリングに渡します。
1. 階層キーリングは、ブランチキーのバージョン、16 バイトのソルト、およびデータキーの暗号化方法を説明する他の情報を含む、暗号化されたデータキーを識別するデータを逆シリアル化します。
詳細については、「[AWS KMS 階層キーリングの技術的な詳細](reference.md#hierarchical-keyring-details)」を参照してください。
1. 階層キーリングは、**ステップ 2** で特定されたブランチキーのバージョンと一致する有効なブランチキーマテリアルがローカルキャッシュ内に存在するかどうかをチェックします。有効なブランチキーマテリアルがある場合、キーリングは**ステップ 6** に進みます。
1. 有効なブランチキーマテリアルがない場合、階層キーリングは、**ステップ 2** で識別されたブランチキーバージョンに一致するブランチキーについてキーストアをクエリします。
1. キーストアは AWS KMS を呼び出してブランチキーを復号し、プレーンテキストのアクティブなブランチキーを返します。アクティブなブランチキーを識別するデータは、 AWS KMSに対する復号呼び出しで追加認証データ (AAD) を提供するためにシリアル化されます。
1. キーストアは、プレーンテキストのブランチキーと、ブランチキーのバージョンなど、それを識別するデータを返します。
1. 階層キーリングはブランチキーマテリアル (プレーンテキストブランチキーとブランチキーバージョン) をアセンブルし、それらのコピーをローカルキャッシュに格納します。
1. 階層キーリングは、アセンブルされたブランチキーマテリアルと、**ステップ 2** で識別された 16 バイトのソルトを使用して、データキーを暗号化した一意のラッピングキーを複製します。
1. 階層キーリングは、複製されたラッピングキーを使用してデータキーを復号し、プレーンテキストのデータキーを返します。
復号メソッドは、復号マテリアルとプレーンテキストデータキーを使用し、レコードを復号して検証します。 AWS Database Encryption SDK でのレコードの復号化と検証の詳細については、[「復号化と検証](how-it-works.md#decrypt-and-verify)」を参照してください。
## 前提条件
階層キーリングを作成して使用する前に、次の前提条件を満たしていることを確認してください。
+ ユーザーまたはキーストア管理者が[キーストアを作成し](create-keystore.md)、[少なくとも 1 つのアクティブなブランチキーを作成](create-branch-keys.md)しました。
+ [キーストアアクションを設定しました](keystore-actions.md#config-keystore-actions)。
**注記**
キーストアアクションの設定方法によって、実行できるオペレーションと、階層キーリングで使用できる KMS キーが決まります。詳細については、[「キーストアアクション](keystore-actions.md)」を参照してください。
+ キーストアキーとブランチキーにアクセスして使用するために必要な AWS KMS アクセス許可があります。詳細については、「[必要なアクセス許可](#hierarchical-keyring-permissions)」を参照してください。
+ サポートされているキャッシュタイプを確認し、ニーズに最適なキャッシュタイプを設定しました。詳細については、[キャッシュを選択する](#hierarchical-keyring-caches)を参照してください。
## 必要なアクセス許可
AWS Database Encryption SDK は を必要とせず AWS アカウント 、 に依存しません AWS のサービス。ただし、階層キーリングを使用するには、 AWS アカウント と、キーストアの対称暗号化 AWS KMS key(複数可) に対する以下の最小限のアクセス許可が必要です。
+ 階層キーリングを使用してデータを暗号化および復号するには、[kms:Decrypt ](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)が必要です。
+ ブランチキー[を作成して](create-branch-keys.md)[ローテーション](rotate-branch-key.md)するには、[kms:GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) と [kms:ReEncrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_ReEncrypt.html) が必要です。
ブランチキーとキーストアへのアクセスの制御の詳細については、「」を参照してください[最小特権のアクセス許可の実装](keystore-least-privilege.md)。
## キャッシュを選択する
階層キーリングは、暗号化および復号オペレーションで使用されるブランチキーマテリアルをローカルにキャッシュ AWS KMS することで、 に対する呼び出しの数を減らします。[階層キーリングを作成する](#initialize-hierarchical-keyring)前に、使用するキャッシュのタイプを決定する必要があります。デフォルトのキャッシュを使用するか、ニーズに合わせてキャッシュをカスタマイズできます。
階層キーリングは、次のキャッシュタイプをサポートしています。
+ [デフォルトキャッシュ](#cache-default)
+ [MultiThreadedキャッシュ](#cache-multithreaded)
+ [StormTracking キャッシュ](#cache-stormtracking)
+ [共有キャッシュ](#cache-shared)
### デフォルトキャッシュ
ほとんどのユーザーにとって、Default キャッシュはスレッド要件を満たします。Default キャッシュは、高度にマルチスレッド化されている環境をサポートするように設計されています。ブランチキーマテリアルエントリの有効期限が切れると、デフォルトキャッシュは、ブランチキーマテリアルエントリが 10 秒前に期限切れになることを 1 つのスレッドに通知 AWS KMS することで、複数のスレッドが呼び出されるのを防ぎます。これにより、1 つのスレッドのみが にリクエストを送信 AWS KMS してキャッシュを更新します。
デフォルトキャッシュと StormTracking キャッシュは同じスレッドモデルをサポートしますが、デフォルトキャッシュを使用するにはエントリ容量を指定するだけです。より詳細なキャッシュのカスタマイズを行うには、 を使用します[StormTracking キャッシュ](#cache-stormtracking)。
ローカルキャッシュに保存できるブランチキーマテリアルエントリの数をカスタマイズする場合を除き、階層キーリングを作成するときにキャッシュタイプを指定する必要はありません。キャッシュタイプを指定しない場合、階層キーリングはデフォルトのキャッシュタイプを使用し、エントリ容量を 1000 に設定します。
デフォルトキャッシュをカスタマイズするには、次の値を指定します。
+ **エントリキャパシティ**: ローカルキャッシュに格納できるブランチキーマテリアルのエントリの数を制限します。
------
#### [ Java ]
```
.cache(CacheType.builder()
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType defaultCache = new CacheType
{
Default = new DefaultCache{EntryCapacity = 100}
};
```
------
#### [ Rust ]
```
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
```
------
### MultiThreadedキャッシュ
MultiThreadedキャッシュはマルチスレッド環境で安全に使用できますが、 AWS KMS または Amazon DynamoDB 呼び出しを最小限に抑える機能はありません。その結果、ブランチキーマテリアルのエントリの期限が切れると、すべてのスレッドに同時に通知されます。これにより、キャッシュを更新するための複数の AWS KMS 呼び出しが発生する可能性があります。
MultiThreaded キャッシュを使用するには、次の値を指定します。
+ **エントリキャパシティ**: ローカルキャッシュに格納できるブランチキーマテリアルのエントリの数を制限します。
+ **エントリのプルーニングテールのサイズ**: エントリキャパシティに達した場合にプルーニングするエントリの数を定義します。
------
#### [ Java ]
```
.cache(CacheType.builder()
.MultiThreaded(MultiThreadedCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType multithreadedCache = new CacheType
{
MultiThreaded = new MultiThreadedCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1
}
};
```
------
#### [ Rust ]
```
CacheType::MultiThreaded(
MultiThreadedCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.build()?)
```
------
### StormTracking キャッシュ
StormTracking キャッシュは、高度にマルチスレッド化されている環境をサポートするように設計されています。ブランチキーマテリアルエントリの有効期限が切れると、StormTracking キャッシュは、ブランチキーマテリアルエントリの有効期限が切れることを 1 つのスレッドに通知 AWS KMS することで、複数のスレッドが呼び出されるのを防ぎます。これにより、1 つのスレッドのみが にリクエストを送信 AWS KMS してキャッシュを更新します。
StormTracking キャッシュを使用するには、次の値を指定します。
+ **エントリキャパシティ**: ローカルキャッシュに格納できるブランチキーマテリアルのエントリの数を制限します。
デフォルト値: 1000 エントリ
+ **エントリのプルーニングテールのサイズ**: 一度にプルーニングするブランチキーマテリアルのエントリの数を定義します。
デフォルトの値: 1 個のエントリ
+ **猶予期間**: 期限が切れる前にブランチキーマテリアルの更新を試行する秒数を定義します。
デフォルト値: 10 秒
+ **猶予間隔**: ブランチキーマテリアルの更新が試行される間隔の秒数を定義します。
デフォルト値: 1 秒
+ **ファンアウト**: ブランチキーマテリアルの更新の同時試行が可能な回数を定義します。
デフォルトの値: 20 回の試行
+ **処理中の Time To Live (TTL)**: ブランチキーマテリアルの更新の試行がタイムアウトするまでの秒数を定義します。キャッシュが `GetCacheEntry` に応答して `NoSuchEntry` を返すたびに、同じキーが `PutCache` エントリを使用して書き込まれるまで、そのブランチキーは処理中であるとみなされます。
デフォルト値: 10 秒
+ **スリープ**: `fanOut` を超えた場合にスレッドがスリープする秒数を定義します。
デフォルトの値: 20 ミリ秒
------
#### [ Java ]
```
.cache(CacheType.builder()
.StormTracking(StormTrackingCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.gracePeriod(10)
.graceInterval(1)
.fanOut(20)
.inFlightTTL(10)
.sleepMilli(20)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType stormTrackingCache = new CacheType
{
StormTracking = new StormTrackingCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1,
FanOut = 20,
GraceInterval = 1,
GracePeriod = 10,
InFlightTTL = 10,
SleepMilli = 20
}
};
```
------
#### [ Rust ]
```
CacheType::StormTracking(
StormTrackingCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.grace_period(10)
.grace_interval(1)
.fan_out(20)
.in_flight_ttl(10)
.sleep_milli(20)
.build()?)
```
------
### 共有キャッシュ
デフォルトでは、階層キーリングは、キーリングをインスタンス化するたびに新しいローカルキャッシュを作成します。ただし、共有キャッシュを使用すると、複数の階層キーリング間でキャッシュを共有できるため、メモリを節約できます。インスタンス化する階層キーリングごとに新しい暗号化マテリアルキャッシュを作成するのではなく、共有キャッシュは 1 つのキャッシュのみをメモリに保存します。このキャッシュは、それを参照するすべての階層キーリングで使用できます。共有キャッシュは、キーリング間での暗号化マテリアルの重複を回避することで、メモリ使用量を最適化するのに役立ちます。代わりに、階層キーリングは同じ基盤となるキャッシュにアクセスし、全体的なメモリフットプリントを削減できます。
共有キャッシュを作成する場合でも、キャッシュタイプを定義します。キャッシュタイプ[StormTracking キャッシュ](#cache-stormtracking)として [デフォルトキャッシュ](#cache-default)、[MultiThreadedキャッシュ](#cache-multithreaded)、または を指定することも、互換性のあるカスタムキャッシュを置き換えることもできます。
**パーティション**
複数の階層キーリングで 1 つの共有キャッシュを使用できます。共有キャッシュを使用して階層キーリングを作成する場合、オプションの**パーティション ID** を定義できます。パーティション ID は、キャッシュに書き込む階層キーリングを区別します。2 つの階層キーリングが同じパーティション ID、[logical key store name](create-keystore.md#logical-key-store-name)、ブランチキー ID を参照する場合、2 つのキーリングはキャッシュ内で同じキャッシュエントリを共有します。同じ共有キャッシュで異なるパーティション IDs を持つ 2 つの階層キーリングを作成すると、各キーリングは共有キャッシュ内の独自の指定されたパーティションからのみキャッシュエントリにアクセスします。パーティションは共有キャッシュ内の論理分割として機能し、各階層キーリングは、他のパーティションに保存されているデータを妨害することなく、独自の指定されたパーティションで独立して動作できます。
パーティション内のキャッシュエントリを再利用または共有する場合は、独自のパーティション ID を定義する必要があります。パーティション ID を階層キーリングに渡すと、キーリングは、ブランチキーマテリアルを再度取得して再承認するのではなく、共有キャッシュに既に存在するキャッシュエントリを再利用できます。パーティション ID を指定しない場合、階層キーリングをインスタンス化するたびに、一意のパーティション ID がキーリングに自動的に割り当てられます。
次の手順は、[デフォルトのキャッシュタイプ](#cache-default)で共有キャッシュを作成し、階層キーリングに渡す方法を示しています。
1. マテリアルプロバイダーライブラリ `CryptographicMaterialsCache` (MPL) を使用して (CMC) を作成します。 [https://github.com/aws/aws-cryptographic-material-providers-library](https://github.com/aws/aws-cryptographic-material-providers-library)
------
#### [ Java ]
```
// Instantiate the MPL
final MaterialProviders matProv =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a CacheType object for the Default cache
final CacheType cache =
CacheType.builder()
.Default(DefaultCache.builder().entryCapacity(100).build())
.build();
// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
CreateCryptographicMaterialsCacheInput.builder()
.cache(cache)
.build();
final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ C\$1 / .NET ]
```
// Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };
// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};
var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ Rust ]
```
// Instantiate the MPL
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create a CacheType object for the default cache
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
// Create a CMC using the default cache
let shared_cryptographic_materials_cache: CryptographicMaterialsCacheRef = mpl.
create_cryptographic_materials_cache()
.cache(cache)
.send()
.await?;
```
------
1. 共有キャッシュの`CacheType`オブジェクトを作成します。
**ステップ 1 **で`sharedCryptographicMaterialsCache`作成した を新しい`CacheType`オブジェクトに渡します。
------
#### [ Java ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
CacheType.builder()
.Shared(sharedCryptographicMaterialsCache)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
```
------
#### [ Rust ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
let shared_cache: CacheType = CacheType::Shared(shared_cryptographic_materials_cache);
```
------
1. **ステップ 2 **の `sharedCache` オブジェクトを階層キーリングに渡します。
共有キャッシュを使用して階層キーリングを作成する場合、オプションで を定義`partitionID`して、複数の階層キーリング間でキャッシュエントリを共有できます。パーティション ID を指定しない場合、階層キーリングはキーリングに一意のパーティション ID を自動的に割り当てます。
**注記**
同じパーティション ID、、[logical key store name](create-keystore.md#logical-key-store-name)ブランチキー ID を参照する 2 つ以上のキーリングを作成すると、階層キーリングは共有キャッシュ内で同じキャッシュエントリを共有します。複数のキーリングで同じキャッシュエントリを共有しない場合は、階層キーリングごとに一意のパーティション ID を使用する必要があります。
次の例では、 で[branch key ID supplier](#branch-key-id-supplier)[キャッシュ制限](#cache-limit)が 600 秒の階層キーリングを作成します。次の階層キーリング設定で定義されている値の詳細については、「」を参照してください[階層キーリングを作成する](#initialize-hierarchical-keyring)。
------
#### [ Java ]
```
// Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(sharedCache)
.partitionID(partitionID)
.build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create the Hierarchical keyring
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
Cache = sharedCache,
TtlSeconds = 600,
PartitionId = partitionID
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
```
------
#### [ Rust ]
```
// Create the Hierarchical keyring
let keyring1 = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store1)
.branch_key_id(branch_key_id.clone())
// CryptographicMaterialsCacheRef is an Rc (Reference Counted), so if you clone it to
// pass it to different Hierarchical Keyrings, it will still point to the same
// underlying cache, and increment the reference count accordingly.
.cache(shared_cache.clone())
.ttl_seconds(600)
.partition_id(partition_id.clone())
.send()
.await?;
```
------
## 階層キーリングを作成する
階層キーリングを作成するには、次の値を指定する必要があります。
+ **キーストア名**
キーストアとして機能するために作成した DynamoDB テーブルの名前、またはキーストア管理者。
+
**キャッシュ制限 Time to Live (TTL)**
ローカルキャッシュ内のブランチキーマテリアルエントリを使用できる時間 (期限切れになるまでの時間) (秒)。キャッシュ制限 TTL は、クライアントがブランチキーの使用を許可 AWS KMS するために を呼び出す頻度を指定します。この値はゼロより大きくなければなりません。キャッシュ制限 TTL の有効期限が切れると、エントリは提供されず、ローカルキャッシュから削除されます。
+ **ブランチキーの識別子**
キーストア内の 1 つのアクティブなブランチキー`branch-key-id`を識別する を静的に設定するか、ブランチキー ID サプライヤーを指定できます。
*ブランチキー ID サプライヤ*は、暗号化コンテキストに保存されているフィールドを使用して、レコードの復号に必要なブランチキーを決定します。デフォルトでは、パーティションキーとソートキーのみが暗号化コンテキストに含まれます。ただし、`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`[暗号化アクション](concepts.md#crypt-actions)を使用して、暗号化コンテキストに追加のフィールドを含めることができます。
各テナントに独自のブランチキーがあるマルチテナントデータベースには、ブランチキー ID サプライヤーを使用することを強くお勧めします。ブランチキー ID サプライヤーを使用してブランチキー IDs のわかりやすい名前を作成し、特定のテナントの正しいブランチキー ID を簡単に認識できます。例えば、フレンドリ名を使用すると、ブランチキーを `b3f61619-4d35-48ad-a275-050f87e15122` の代わりに `tenant1` として参照できます。
復号オペレーションの場合、単一の階層キーリングを静的に設定して復号を単一のテナンシーに制限することも、ブランチキー ID サプライヤーを使用してレコードの復号を担当するテナンシーを識別することもできます。
+ **(オプション) キャッシュ**
キャッシュタイプまたはローカルキャッシュに格納できるブランチキーマテリアルエントリの数をカスタマイズする場合は、キーリングを初期化する際にキャッシュタイプとエントリキャパシティを指定します。
階層キーリングは、デフォルト、MultiThreaded、StormTracking、共有のキャッシュタイプをサポートします。各キャッシュタイプを定義する方法の詳細と例については、「」を参照してください[キャッシュを選択する](#hierarchical-keyring-caches)。
キャッシュを指定しない場合、階層キーリングは、自動的に Default キャッシュタイプを使用し、エントリキャパシティを 1,000 に設定します。
+ **(オプション) パーティション ID**
を指定する場合は[共有キャッシュ](#cache-shared)、オプションでパーティション ID を定義できます。パーティション ID は、キャッシュに書き込む階層キーリングを区別します。パーティション内のキャッシュエントリを再利用または共有する場合は、独自のパーティション ID を定義する必要があります。パーティション ID には任意の文字列を指定できます。パーティション ID を指定しない場合、作成時に一意のパーティション ID がキーリングに自動的に割り当てられます。
詳細については、「[Partitions](#shared-cache-partitions)」を参照してください。
**注記**
同じパーティション ID、、ブランチキー ID を参照する 2 つ以上のキーリングを作成する[logical key store name](create-keystore.md#logical-key-store-name)と、階層キーリングは共有キャッシュ内で同じキャッシュエントリを共有します。複数のキーリングで同じキャッシュエントリを共有しない場合は、階層キーリングごとに一意のパーティション ID を使用する必要があります。
+ **(オプション) 許可トークンのリスト**
階層キーリング内の KMS キーへのアクセスを[許可](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)によって制御する場合は、キーリングを初期化する際に必要なすべての許可トークンを指定する必要があります。
### 静的ブランチキー ID を使用して階層キーリングを作成する
次の例は、静的ブランチキー ID、、[デフォルトキャッシュ](#cache-default)キャッシュ制限 TTL が 600 秒の階層キーリングを作成する方法を示しています。
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyId(branch-key-id)
.ttlSeconds(600)
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(branch_key_store_name)
.ttl_seconds(600)
.send()
.await?;
```
------
### ブランチキー ID サプライヤーを使用して階層キーリングを作成する
次の手順は、ブランチキー ID サプライヤーを使用して階層キーリングを作成する方法を示しています。
1. ブランチキー ID サプライヤーを作成する
次の例では、**ステップ 1 **で作成した 2 つのブランチキーのフレンドリ名を作成し、 `CreateDynamoDbEncryptionBranchKeyIdSupplier`を呼び出して AWS Database Encryption SDK for DynamoDB クライアントを使用してブランチキー ID サプライヤーを作成します。
------
#### [ Java ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
private static String branchKeyIdForTenant1;
private static String branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this.branchKeyIdForTenant1 = tenant1Id;
this.branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
.DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
.build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
.ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2))
.build()).branchKeyIdSupplier();
```
------
#### [ C\$1 / .NET ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
private String _branchKeyIdForTenant1;
private String _branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this._branchKeyIdForTenant1 = tenant1Id;
this._branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
{
DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2)
}).BranchKeyIdSupplier;
```
------
#### [ Rust ]
```
// Create friendly names for each branch_key_id
pub struct ExampleBranchKeyIdSupplier {
branch_key_id_for_tenant1: String,
branch_key_id_for_tenant2: String,
}
impl ExampleBranchKeyIdSupplier {
pub fn new(tenant1_id: &str, tenant2_id: &str) -> Self {
Self {
branch_key_id_for_tenant1: tenant1_id.to_string(),
branch_key_id_for_tenant2: tenant2_id.to_string(),
}
}
}
// Create the branch key ID supplier
let dbesdk_config = DynamoDbEncryptionConfig::builder().build()?;
let dbesdk = dbesdk_client::Client::from_conf(dbesdk_config)?;
let supplier = ExampleBranchKeyIdSupplier::new(tenant1_branch_key_id, tenant2_branch_key_id);
let branch_key_id_supplier = dbesdk
.create_dynamo_db_encryption_branch_key_id_supplier()
.ddb_key_branch_key_id_supplier(supplier)
.send()
.await?
.branch_key_id_supplier
.unwrap();
```
------
1. 階層キーリングを作成する
次の例では、**ステップ 1 **で作成したブランチキー ID サプライヤー、キャッシュ制限 TLL が 600 秒、最大キャッシュサイズが 1000 の階層キーリングを初期化します。
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
.build())
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 100 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id_supplier(branch_key_id_supplier)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
------
## 検索可能な暗号化のための階層キーリングの使用
[検索可能な暗号化](searchable-encryption.md)を使用すると、データベース全体を復号することなく、暗号化されたレコードを検索できます。これは、[ビーコン](beacons.md)を使用して暗号化されたフィールドのプレーンテキストの値にインデックスを付けることで実現されます。検索可能な暗号化を実装するには、階層キーリングを使用する必要があります。
キーストア `CreateKey` オペレーションは、ブランチキーとビーコンキーの両方を生成します。ブランチキーは、レコードの暗号化および復号オペレーションで使用されます。ビーコンキーは、ビーコンを生成するために使用されます。
ブランチキーとビーコンキーは、キーストアサービスの作成時に指定した AWS KMS key ものと同じ によって保護されます。`CreateKey` オペレーションが AWS KMS を呼び出してブランチキーを生成すると、[kms:GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) を 2 回呼び出して、次のリクエストを使用してビーコンキーを生成します。
```
{
"EncryptionContext": {
"branch-key-id" : "branch-key-id",
"type" : type,
"create-time" : "timestamp",
"tablename" : "the logical table name for your key store",
"kms-arn" : the KMS key ARN,
"hierarchy-version" : 1
},
"KeyId": "the KMS key ARN",
"NumberOfBytes": "32"
}
```
両方のキーを生成した後、`CreateKey` オペレーションは [ddb:TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) を呼び出して、ブランチキーとビーコンキーを永続化する 2 つの新しい項目をブランチキーストアに書き込みます。
[標準ビーコンを設定する](configure-beacons.md#config-standard-beacons)と、 AWS Database Encryption SDK はキーストアにビーコンキーをクエリします。その後、HMAC ベースの extract-and-expand 鍵導出関数 ([HKDF](https://en.wikipedia.org/wiki/HKDF)) を使用して、ビーコンキーと[標準ビーコン](beacons.md#standard-beacon-overview)の名前を組み合わせ、特定のビーコンの HMAC キーを作成します。
ブランチキーとは異なり、キーストア`branch-key-id`には ごとに 1 つのビーコンキーバージョンしかありません。ビーコンキーがローテーションされることはありません。
### ビーコンキーソースの定義
標準ビーコンおよび複合ビーコンの[ビーコンバージョン](using-beacons.md#beacon-version)を定義する際には、ビーコンキーを識別し、ビーコンキーマテリアルのキャッシュ制限 Time To Live (TTL) を定義する必要があります。ビーコンキーマテリアルは、ブランチキーとは別のローカルキャッシュに格納されます。次のスニペットは、シングルテナンシーデータベースの `keySource` を定義する方法を示しています。関連付けられている `branch-key-id` によってビーコンキーを識別します。
------
#### [ Java ]
```
keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branch-key-id)
.cacheTTL(6000)
.build())
.build())
```
------
#### [ C\$1 / .NET ]
```
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000
}
}
```
------
#### [ Rust ]
```
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
// `keyId` references a beacon key.
// For every branch key we create in the keystore,
// we also create a beacon key.
// This beacon key is not the same as the branch key,
// but is created with the same ID as the branch key.
.key_id(branch_key_id)
.cache_ttl(6000)
.build()?,
))
```
------
**マルチテナンシーデータベースでのビーコンソースの定義**
マルチテナンシーデータベースがある場合は、`keySource` を設定する際に次の値を指定する必要があります。
+
**keyFieldName**
特定のテナンシーについて生成されたビーコンに使用されるビーコンキーに関連付けられた `branch-key-id` を格納するフィールドの名前を定義します。`keyFieldName` には任意の文字列を指定できますが、データベース内の他のすべてのフィールドで一意である必要があります。新しいレコードをデータベースに書き込むと、そのレコードについてのビーコンを生成するために使用されるビーコンキーを識別する `branch-key-id` がこのフィールドに格納されます。このフィールドをビーコンクエリに含めて、ビーコンの再計算に必要となる適切なビーコンキーマテリアルを特定する必要があります。詳細については、「[マルチテナンシーデータベース内のビーコンのクエリ](searchable-encryption-multitenant.md#query-multitenant-beacons)」を参照してください。
+ **cacheTTL**
ローカルビーコンキャッシュ内のビーコンキーマテリアルエントリを使用できる時間 (期限切れになるまでの時間) (秒)。この値はゼロより大きくなければなりません。キャッシュ制限 TTL の期限が切れると、エントリはローカルキャッシュから削除されます。
+ **(オプション) キャッシュ**
キャッシュタイプまたはローカルキャッシュに格納できるブランチキーマテリアルエントリの数をカスタマイズする場合は、キーリングを初期化する際にキャッシュタイプとエントリキャパシティを指定します。
階層キーリングは、デフォルト、MultiThreaded、StormTracking、共有のキャッシュタイプをサポートします。各キャッシュタイプを定義する方法の詳細と例については、「」を参照してください[キャッシュを選択する](#hierarchical-keyring-caches)。
キャッシュを指定しない場合、階層キーリングは、自動的に Default キャッシュタイプを使用し、エントリキャパシティを 1,000 に設定します。
次の例では、ブランチキー ID サプライヤー、キャッシュ制限 TLL が 600 秒、エントリ容量が 1000 の階層キーリングを作成します。
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(1000)
.build())
.build());
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 1000 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
# AWS KMS ECDH キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
**重要**
AWS KMS ECDH キーリングは、 マテリアルプロバイダーライブラリのバージョン 1.5.0 以降でのみ使用できます。
AWS KMS ECDH キーリングは、非対称キーアグリーメント[AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/key-types.html)を使用して、2 つの当事者間で共有対称ラッピングキーを取得します。まず、キーリングは楕円曲線 Diffie-Hellman (ECDH) キーアグリーメントアルゴリズムを使用して、送信者の KMS キーペアと受信者のパブリックキーのプライベートキーから共有シークレットを取得します。次に、キーリングは共有シークレットを使用して、データ暗号化キーを保護する共有ラッピングキーを取得します。 AWS Database Encryption SDK が (`KDF_CTR_HMAC_SHA384`) を使用して共有ラッピングキーを取得するキー取得関数は、[キー取得に関する NIST レコメンデーション](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf)に準拠しています。
キー取得関数は、64 バイトのキーマテリアルを返します。両当事者が正しいキーマテリアルを使用していることを確認するために、 AWS Database Encryption SDK は最初の 32 バイトをコミットメントキーとして使用し、最後の 32 バイトを共有ラッピングキーとして使用します。復号時に、キーリングが暗号化されたレコードのマテリアル説明フィールドに保存されているのと同じコミットメントキーと共有ラッピングキーを再現できない場合、オペレーションは失敗します。たとえば、**Alice の**プライベートキーと **Bob の**パブリックキーで設定されたキーリングを使用してレコードを暗号化する場合、**Bob の**プライベートキーと **Alice の**パブリックキーで設定されたキーリングは、同じコミットメントキーと共有ラッピングキーを再現し、レコードを復号化できます。Bob のパブリックキーが KMS キーペアからでない場合、Bob は [Raw ECDH キーリング](use-raw-ecdh-keyring.md)を作成してレコードを復号できます。
AWS KMS ECDH キーリングは、AES-GCM を使用して対称キーでレコードを暗号化します。次に、データキーは、AES-GCM を使用して派生した共有ラッピングキーでエンベロープ暗号化されます。各 AWS KMS ECDH キーリングには 1 つの共有ラッピングキーのみを含めることができますが、複数の AWS KMS ECDH キーリングを単独で、または他のキーリングと共に[マルチキーリング](use-multi-keyring.md)に含めることができます。
**Topics**
+ [AWS KMS ECDH キーリングに必要なアクセス許可](#kms-ecdh-permissions)
+ [AWS KMS ECDH キーリングの作成](#kms-ecdh-create)
+ [AWS KMS ECDH 検出キーリングの作成](#kms-ecdh-discovery)
## AWS KMS ECDH キーリングに必要なアクセス許可
AWS Database Encryption SDK は AWS アカウントを必要とせず、どの AWS サービスにも依存しません。ただし、 AWS KMS ECDH キーリングを使用するには、 AWS アカウントと、キーリング AWS KMS keys の に対する以下の最小限のアクセス許可が必要です。アクセス許可は、使用するキーアグリーメントスキーマによって異なります。
+ `KmsPrivateKeyToStaticPublicKey` キーアグリーメントスキーマを使用してレコードを暗号化および復号するには、*送信者の*非対称 KMS [キーペアに kms:GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) と [kms:DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) が必要です。キーリングをインスタンス化するときに送信者の DER エンコードされたパブリックキーを直接指定する場合、送信者の非対称 KMS キーペアに対する [kms:DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) アクセス許可のみが必要です。
+ `KmsPublicKeyDiscovery` キーアグリーメントスキーマを使用してレコードを復号するには、指定された非対称 [KMS キーペアに対する kms:DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) および [kms:GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) アクセス許可が必要です。
## AWS KMS ECDH キーリングの作成
データを暗号化および復号する AWS KMS ECDH キーリングを作成するには、`KmsPrivateKeyToStaticPublicKey`キーアグリーメントスキーマを使用する必要があります。キーアグリーメントスキーマを使用して AWS KMS ECDH `KmsPrivateKeyToStaticPublicKey` キーリングを初期化するには、次の値を指定します。
+ **送信者の AWS KMS key ID**
`KeyUsage` 値が の非対称 NIST 推奨楕円曲線 (ECC)KMS キーペアを識別する必要があります`KEY_AGREEMENT`。送信者のプライベートキーは、共有シークレットを取得するために使用されます。
+ **(オプション) 送信者のパブリックキー**
RFC 5280 で定義されているように、 `SubjectPublicKeyInfo` (SPKI) とも呼ばれる DER エンコードされた X.509 パブリックキーである必要があります。 [https://tools.ietf.org/html/rfc5280](https://tools.ietf.org/html/rfc5280)
AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) オペレーションは、非対称 KMS キーペアのパブリックキーを必要な DER エンコード形式で返します。
キーリングが行う AWS KMS 呼び出しの数を減らすには、送信者のパブリックキーを直接指定できます。送信者のパブリックキーに値が指定されていない場合、キーリングは AWS KMS を呼び出して送信者のパブリックキーを取得します。
+ **受信者のパブリックキー**
RFC 5280 で定義されているように、(`SubjectPublicKeyInfo`SPKI) とも呼ばれる受信者の DER エンコードされた X.509 パブリックキーを指定する必要があります。 [https://tools.ietf.org/html/rfc5280](https://tools.ietf.org/html/rfc5280)
AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) オペレーションは、非対称 KMS キーペアのパブリックキーを必要な DER エンコード形式で返します。
+ **曲線仕様**
指定されたキーペアの楕円曲線仕様を識別します。送信者と受信者の両方のキーペアは、同じ曲線仕様である必要があります。
有効な値: `ECC_NIST_P256`、`ECC_NIS_P384`、`ECC_NIST_P512`
+ **(オプション) 許可トークンのリスト**
AWS KMS ECDH キーリングの KMS キーへのアクセスを[グラン](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)トで制御する場合は、キーリングを初期化するときに必要なすべてのグラントトークンを指定する必要があります。
------
#### [ C\$1 / .NET ]
次の例では、送信者の KMS キー、送信者のパブリックキー、受信者のパブリックキーを使用して、 を使用して AWS KMS ECDH キーリングを作成します。この例では、オプションの `senderPublicKey`パラメータを使用して、送信者のパブリックキーを指定します。送信者のパブリックキーを指定しない場合、キーリングは AWS KMS を呼び出して送信者のパブリックキーを取得します。送信者と受信者の両方のキーペアが`ECC_NIST_P256`曲線上にあります。
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Must be DER-encoded X.509 public keys
var BobPublicKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the AWS KMS ECDH static keyring
var staticConfiguration = new KmsEcdhStaticConfigurations
{
KmsPrivateKeyToStaticPublicKey = new KmsPrivateKeyToStaticPublicKeyInput
{
SenderKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
SenderPublicKey = BobPublicKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
次の例では、送信者の KMS キー、送信者のパブリックキー、受信者のパブリックキーを使用して、 を使用して AWS KMS ECDH キーリングを作成します。この例では、オプションの `senderPublicKey`パラメータを使用して、送信者のパブリックキーを指定します。送信者のパブリックキーを指定しない場合、キーリングは AWS KMS を呼び出して送信者のパブリックキーを取得します。送信者と受信者の両方のキーペアが`ECC_NIST_P256`曲線上にあります。
```
// Retrieve public keys
// Must be DER-encoded X.509 public keys
ByteBuffer BobPublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab");
ByteBuffer AlicePublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the AWS KMS ECDH static keyring
final CreateAwsKmsEcdhKeyringInput senderKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput.builder()
.senderKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
.senderPublicKey(BobPublicKey)
.recipientPublicKey(AlicePublicKey)
.build()).build()).build();
```
------
#### [ Rust ]
次の例では、送信者の KMS キー、送信者のパブリックキー、受信者のパブリックキーを使用して、 を使用して AWS KMS ECDH キーリングを作成します。この例では、オプションの `sender_public_key`パラメータを使用して、送信者のパブリックキーを指定します。送信者のパブリックキーを指定しない場合、キーリングは AWS KMS を呼び出して送信者のパブリックキーを取得します。
```
// Retrieve public keys
// Must be DER-encoded X.509 keys
let public_key_file_content_sender = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_SENDER))?;
let parsed_public_key_file_content_sender = parse(public_key_file_content_sender)?;
let public_key_sender_utf8_bytes = parsed_public_key_file_content_sender.contents();
let public_key_file_content_recipient = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content_recipient = parse(public_key_file_content_recipient)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content_recipient.contents();
// Create KmsPrivateKeyToStaticPublicKeyInput
let kms_ecdh_static_configuration_input =
KmsPrivateKeyToStaticPublicKeyInput::builder()
.sender_kms_identifier(arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab)
// Must be a UTF8 DER-encoded X.509 public key
.sender_public_key(public_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let kms_ecdh_static_configuration = KmsEcdhStaticConfigurations::KmsPrivateKeyToStaticPublicKey(kms_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH keyring
let kms_ecdh_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client)
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_static_configuration)
.send()
.await?;
```
------
## AWS KMS ECDH 検出キーリングの作成
復号するときは、 AWS Database Encryption SDK が使用できるキーを指定するのがベストプラクティスです。このベストプラクティスに従うには、`KmsPrivateKeyToStaticPublicKey`キーアグリーメントスキーマで AWS KMS ECDH キーリングを使用します。ただし、 AWS KMS ECDH 検出キーリング、つまり、指定された KMS キーペアのパブリックキーが、暗号化されたレコードのマテリアル説明フィールドに保存されている*受信者*のパブリックキーと一致するレコードを復号できる AWS KMS ECDH キーリングを作成することもできます。
**重要**
`KmsPublicKeyDiscovery` キーアグリーメントスキーマを使用してレコードを復号する場合、所有者に関係なく、すべてのパブリックキーを受け入れます。
キーアグリーメントスキーマを使用して AWS KMS ECDH `KmsPublicKeyDiscovery` キーリングを初期化するには、次の値を指定します。
+ **受信者の AWS KMS key ID**
`KeyUsage` 値が の非対称 NIST 推奨楕円曲線 (ECC)KMS キーペアを識別する必要があります`KEY_AGREEMENT`。
+ **曲線仕様**
受信者の KMS キーペアの楕円曲線仕様を識別します。
有効な値: `ECC_NIST_P256`、`ECC_NIS_P384`、`ECC_NIST_P512`
+ **(オプション) 許可トークンのリスト**
AWS KMS ECDH キーリングの KMS キーへのアクセスを[グラン](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html)トで制御する場合は、キーリングを初期化するときに必要なすべてのグラントトークンを指定する必要があります。
------
#### [ C\$1 / .NET ]
次の例では、`ECC_NIST_P256`曲線に KMS キーペアを持つ AWS KMS ECDH 検出キーリングを作成します。指定された [KMS キーペアに対する kms:GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) および [kms:DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) アクセス許可が必要です。このキーリングは、指定された KMS キーペアのパブリックキーが、暗号化されたレコードのマテリアル説明フィールドに保存されている受信者のパブリックキーと一致するレコードを復号できます。
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create the AWS KMS ECDH discovery keyring
var discoveryConfiguration = new KmsEcdhStaticConfigurations
{
KmsPublicKeyDiscovery = new KmsPublicKeyDiscoveryInput
{
RecipientKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
次の例では、`ECC_NIST_P256`曲線に KMS キーペアを持つ AWS KMS ECDH 検出キーリングを作成します。指定された [KMS キーペアに対する kms:GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) および [kms:DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) アクセス許可が必要です。このキーリングは、指定された KMS キーペアのパブリックキーが、暗号化されたレコードのマテリアル説明フィールドに保存されている受信者のパブリックキーと一致するレコードを復号できます。
```
// Create the AWS KMS ECDH discovery keyring
final CreateAwsKmsEcdhKeyringInput recipientKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput.builder()
.recipientKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321").build()
).build())
.build();
```
------
#### [ Rust ]
```
// Create KmsPublicKeyDiscoveryInput
let kms_ecdh_discovery_static_configuration_input =
KmsPublicKeyDiscoveryInput::builder()
.recipient_kms_identifier(ecc_recipient_key_arn)
.build()?;
let kms_ecdh_discovery_static_configuration = KmsEcdhStaticConfigurations::KmsPublicKeyDiscovery(kms_ecdh_discovery_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH discovery keyring
let kms_ecdh_discovery_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client.clone())
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_discovery_static_configuration)
.send()
.await?;
```
------
# Raw AES キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
AWS Database Encryption SDK では、データキーを保護するラッピングキーとして指定した AES 対称キーを使用できます。キーマテリアルを生成、格納、保護する必要があります (ハードウェアセキュリティモジュール (HSM) またはキー管理システムで行うのが好ましいです)。ラッピングキーを指定し、ローカルまたはオフラインでデータキーを暗号化する必要がある場合は、Raw AES キーリングを使用します。
Raw AES キーリングは、AES-GCM アルゴリズムと、バイト配列として指定したラッピングキーを使用することによってデータを暗号化します。各 Raw AES キーリングで指定できるラッピングキーは 1 つだけですが、複数の Raw AES キーリングを単独で、または他のキーリングとともに[マルチキーリング](use-multi-keyring.md)に含めることができます。
**主要な名前空間と名前**
キーリング内の AES キーを識別するために、Raw AES キーリングは、指定したキーの名前空間とキー名を使用します。これらの値はシークレットではありません。Database AWS Encryption SDK がレコードに追加する[マテリアルの説明](concepts.md#material-description)にプレーンテキストで表示されます。HSM またはキー管理システムのキーの名前空間と、そのシステムで AES キーを識別するキー名を使用することをお勧めします。
**注記**
キーの名前空間とキー名は、`JceMasterKey` の [プロバイダー ID] (または [プロバイダー]) フィールドと [キー ID] フィールドに相当します。
特定のフィールドを暗号化および復号するために異なるキーリングを構築する場合、名前空間と名前の値が重要です。復号キーリング内のキーの名前空間とキー名が、暗号化キーリング内のキーの名前空間とキー名の大文字と小文字の区別に正確に一致しない場合、キーマテリアルのバイトが同一であっても、復号キーリングは使用されません。
例えば、キーの名前空間 `HSM_01` とキー名 `AES_256_012` を使用して Raw AES キーリングを定義するとします。その後、そのキーリングを使用して一部のデータを暗号化します。そのデータを復号するには、同じキー名前空間、キー名、およびキーマテリアルを使用して Raw AES キーリングを作成します。
次の例は、Raw AES キーリングの作成方法を示しています。`AESWrappingKey` 変数は、指定したキーマテリアルを表します。
------
#### [ Java ]
```
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
// This example uses the key generator in Bouncy Castle to generate the key material.
// In production, use key material from a secure source.
var aesWrappingKey = new MemoryStream(GeneratorUtilities.GetKeyGenerator("AES256").GenerateKey());
// Create the keyring
var keyringInput = new CreateRawAesKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var matProv = new MaterialProviders(new MaterialProvidersConfig());
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
```
------
# Raw RSA キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
Raw RSA キーリングは、指定した RSA パブリックキーとプライベートキーを使用して、ローカルメモリでデータキーの非対称の暗号化と復号を実行します。プライベートキーを生成、格納、保護する必要があります (ハードウェアセキュリティモジュール (HSM) またはキー管理システムで行うのが好ましいです)。暗号化関数を使用して、RSA パブリックキーのデータキーを暗号化します。復号関数でプライベートキーを使用して、データキーを復号します。複数の RSA パディングモードから選択できます。
暗号化と復号を行う Raw RSA キーリングには、非対称のパブリックキーとプライベートキーのペアを含める必要があります。ただし、データの暗号化は、パブリックキーのみを持つ Raw RSA キーリングを使用して行うことができます。また、データの復号は、プライベートキーのみを持つ Raw RSA キーリングを使用して行うことができます。Raw RSA キーリングは、[マルチキーリング](use-multi-keyring.md)に含めることができます。Raw RSA キーリングをパブリックキーおよびプライベートキーを使用して設定する場合は、それらが同じキーペアの一部であることを確認してください。
Raw RSA キーリングは、RSA 非対称暗号化キーで使用される AWS Encryption SDK for Java 場合、 の [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html) と同等であり、相互運用されます。
**注記**
Raw RSA キーリングは、非対称 KMS キーをサポートしません。非対称 RSA KMS キーを使用するには、[AWS KMS キーリング](use-kms-keyring.md)を構築します。
**名前空間と名前**
キーリング内の RSA キーマテリアルを識別するために、Raw RSA キーリングは、指定したキーの名前空間とキー名を使用します。これらの値はシークレットではありません。Database AWS Encryption SDK がレコードに追加する[マテリアルの説明](concepts.md#material-description)にプレーンテキストで表示されます。HSM またはキー管理システムで RSA キーペア (またはそのプライベートキー) を識別するキーの名前空間とキー名を使用することをお勧めします。
**注記**
キーの名前空間とキー名は、`JceMasterKey` の [プロバイダー ID] (または [プロバイダー]) フィールドと [キー ID] フィールドに相当します。
特定のレコードを暗号化および復号するために異なるキーリングを構築する場合、名前空間と名前の値が重要です。復号キーリング内のキーの名前空間とキー名が、暗号化キーリング内のキーの名前空間とキー名の大文字と小文字の区別に正確に一致しない場合、そのキーが同じキーペアからのものであっても、復号キーリングは使用されません。
暗号化および復号キーリング内のキーマテリアルのキーの名前空間とキー名は、キーリングのキーペアに RSA パブリックキー、RSA プライベートキー、または両方のキーが含まれているかどうかにかかわらず、同じである必要があります。例えば、キーの名前空間 `HSM_01` とキー名 `RSA_2048_06` を持つ RSA パブリックキーの Raw RSA キーリングを使用してデータを暗号化するとします。そのデータを復号するには、プライベートキー (またはキーペア)、および同じキーの名前空間と名前を使用して Raw RSA キーリングを構築します。
**パディングモード**
暗号化と復号に使用される Raw RSA キーリングのためにパディングモードを指定するか、またはそれを指定する言語実装の機能を使用する必要があります。
は、各言語の制約に従い、次のパディングモード AWS Encryption SDK をサポートしています。[OAEP](https://tools.ietf.org/html/rfc8017#section-7.1) パディングモード、特に SHA-256 を使用する OAEP および SHA-256 パディングを使用する MGF1 をお勧めします。[PKCS1](https://tools.ietf.org/html/rfc8017#section-7.2) パディングモードは、下位互換性のためのみサポートされています。
+ SHA-1 を使用する OAEP および SHA-1 パディングを使用する MGF1
+ SHA-256 を使用する OAEP および SHA-256 パディングを使用する MGF1
+ SHA-384 を使用する OAEP および SHA-384 パディングを使用する MGF1
+ SHA-512 を使用する OAEP および SHA-512 パディングを使用する MGF1
+ PKCS1 v1.5 パディング
次の Java の例は、RSA キーペアのパブリックキーとプライベートキーを使用し、SHA-256 を使用する OAEP および SHA-256 パディングモードを使用する MGF1 を採用する Raw RSA キーリングを作成する方法を示しています。`RSAPublicKey` および `RSAPrivateKey` 変数は、指定するキーマテリアルを表します。
------
#### [ Java ]
```
final CreateRawRsaKeyringInput keyringInput = CreateRawRsaKeyringInput.builder()
.keyName("RSA_2048_06")
.keyNamespace("HSM_01")
.paddingScheme(PaddingScheme.OAEP_SHA256_MGF1)
.publicKey(RSAPublicKey)
.privateKey(RSAPrivateKey)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "RSA_2048_06";
// Get public and private keys from PEM files
var publicKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePublicKey.pem"));
var privateKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePrivateKey.pem"));
// Create the keyring input
var keyringInput = new CreateRawRsaKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
PaddingScheme = PaddingScheme.OAEP_SHA512_MGF1,
PublicKey = publicKey,
PrivateKey = privateKey
};
// Create the keyring
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_rsa_keyring = mpl
.create_raw_rsa_keyring()
.key_name("RSA_2048_06")
.key_namespace("HSM_01")
.padding_scheme(PaddingScheme::OaepSha256Mgf1)
.public_key(RSA_public_key)
.private_key(RSA_private_key)
.send()
.await?;
```
------
# Raw ECDH キーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
**重要**
Raw ECDH キーリングは、マテリアルプロバイダーライブラリのバージョン 1.5.0 でのみ使用できます。
Raw ECDH キーリングは、指定した楕円曲線のパブリック/プライベートキーペアを使用して、2 つの当事者間で共有ラッピングキーを取得します。まず、キーリングは、送信者のプライベートキー、受信者のパブリックキー、楕円曲線 Diffie-Hellman (ECDH) キーアグリーメントアルゴリズムを使用して共有シークレットを取得します。次に、キーリングは共有シークレットを使用して、データ暗号化キーを保護する共有ラッピングキーを取得します。 AWS Database Encryption SDK が (`KDF_CTR_HMAC_SHA384`) を使用して共有ラッピングキーを取得するキー取得関数は、[キー取得に関する NIST レコメンデーション](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf)に準拠しています。
キー取得関数は、64 バイトのキーマテリアルを返します。両当事者が正しいキーマテリアルを使用するように、 AWS Database Encryption SDK は最初の 32 バイトをコミットメントキーとして使用し、最後の 32 バイトを共有ラッピングキーとして使用します。復号時に、キーリングが暗号化されたレコードのマテリアル説明フィールドに保存されているのと同じコミットメントキーと共有ラッピングキーを再現できない場合、オペレーションは失敗します。たとえば、**Alice の**プライベートキーと **Bob の**パブリックキーで設定されたキーリングを使用してレコードを暗号化する場合、**Bob の**プライベートキーと **Alice の**パブリックキーで設定されたキーリングは、同じコミットメントキーと共有ラッピングキーを再現し、レコードを復号化できます。Bob のパブリックキーが AWS KMS key ペアからのものである場合、Bob は [AWS KMS ECDH キーリング](use-kms-ecdh-keyring.md)を作成してレコードを復号できます。
Raw ECDH キーリングは、AES-GCM を使用して対称キーでレコードを暗号化します。次に、データキーは、AES-GCM を使用して派生した共有ラッピングキーでエンベロープ暗号化されます。各 Raw ECDH キーリングには 1 つの共有ラッピングキーのみを含めることができますが、複数の Raw ECDH キーリングを単独で、または他のキーリングと共に[マルチキーリング](use-multi-keyring.md)に含めることができます。
プライベートキーの生成、保存、保護は、ハードウェアセキュリティモジュール (HSM) またはキー管理システムで行うことをお勧めします。送信者と受信者のキーペアは、ほぼ同じ楕円曲線上にあります。 AWS Database Encryption SDK は、次の楕円曲線仕様をサポートしています。
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`
## Raw ECDH キーリングの作成
Raw ECDH キーリングは、`RawPrivateKeyToStaticPublicKey`、、 `EphemeralPrivateKeyToStaticPublicKey`の 3 つのキーアグリーメントスキーマをサポートしています`PublicKeyDiscovery`。選択したキーアグリーメントスキーマによって、実行できる暗号化オペレーションとキーマテリアルの組み立て方法が決まります。
**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)
### RawPrivateKeyToStaticPublicKey
`RawPrivateKeyToStaticPublicKey` キーアグリーメントスキーマを使用して、キーリングで送信者のプライベートキーと受信者のパブリックキーを静的に設定します。このキーアグリーメントスキーマは、レコードを暗号化および復号化できます。
`RawPrivateKeyToStaticPublicKey` キーアグリーメントスキーマを使用して Raw ECDH キーリングを初期化するには、次の値を指定します。
+ **送信者のプライベートキー**
[RFC 595](https://tools.ietf.org/html/rfc5958#section-2)8 で定義されているように、送信者の PEM エンコードされたプライベートキー (PKCS \$18 PrivateKeyInfo 構造) を指定する必要があります。
+ **受信者のパブリックキー**
RFC 5280 で定義されているように、(`SubjectPublicKeyInfo`SPKI) とも呼ばれる受信者の DER エンコードされた X.509 パブリックキーを指定する必要があります。 [https://tools.ietf.org/html/rfc5280](https://tools.ietf.org/html/rfc5280)
非対称キーアグリーメント KMS キーペアのパブリックキー、または の外部で生成されたキーペアのパブリックキーを指定できます AWS。
+ **曲線仕様**
指定されたキーペアの楕円曲線仕様を識別します。送信者と受信者の両方のキーペアには、同じ曲線仕様が必要です。
有効な値: `ECC_NIST_P256`、`ECC_NIS_P384`、`ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var BobPrivateKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH static keyring
var staticConfiguration = new RawEcdhStaticConfigurations()
{
RawPrivateKeyToStaticPublicKey = new RawPrivateKeyToStaticPublicKeyInput
{
SenderStaticPrivateKey = BobPrivateKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
次の Java の例では、`RawPrivateKeyToStaticPublicKey`キーアグリーメントスキーマを使用して、送信者のプライベートキーと受信者のパブリックキーを静的に設定します。両方のキーペアが`ECC_NIST_P256`曲線上にあります。
```
private static void StaticRawKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair senderKeys = GetRawEccKey();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH static keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.RawPrivateKeyToStaticPublicKey(
RawPrivateKeyToStaticPublicKeyInput.builder()
// Must be a PEM-encoded private key
.senderStaticPrivateKey(ByteBuffer.wrap(senderKeys.getPrivate().getEncoded()))
// Must be a DER-encoded X.509 public key
.recipientPublicKey(ByteBuffer.wrap(recipient.getPublic().getEncoded()))
.build()
)
.build()
).build();
final IKeyring staticKeyring = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
次の Python の例では、`raw_ecdh_static_configuration`キーアグリーメントスキーマを使用して、送信者のプライベートキーと受信者のパブリックキーを静的に設定します。両方のキーペアが同じ曲線上にある必要があります。
```
// Create keyring input
let raw_ecdh_static_configuration_input =
RawPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 PEM-encoded private key
.sender_static_private_key(private_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let raw_ecdh_static_configuration = RawEcdhStaticConfigurations::RawPrivateKeyToStaticPublicKey(raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH static keyring
let raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(raw_ecdh_static_configuration)
.send()
.await?;
```
------
### EphemeralPrivateKeyToStaticPublicKey
キーアグリーメントスキーマで設定された`EphemeralPrivateKeyToStaticPublicKey`キーリングは、新しいキーペアをローカルに作成し、暗号化呼び出しごとに一意の共有ラッピングキーを取得します。
このキーアグリーメントスキーマはレコードのみを暗号化できます。`EphemeralPrivateKeyToStaticPublicKey` キーアグリーメントスキーマで暗号化されたレコードを復号するには、同じ受信者のパブリックキーで設定された検出キーアグリーメントスキーマを使用する必要があります。復号するには、[`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)キーアグリーメントアルゴリズムで Raw ECDH キーリングを使用するか、受信者のパブリックキーが非対称キーアグリーメント KMS キーペアからのものである場合は、[KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery) キーアグリーメントスキーマで AWS KMS ECDH キーリングを使用できます。
`EphemeralPrivateKeyToStaticPublicKey` キーアグリーメントスキーマを使用して Raw ECDH キーリングを初期化するには、次の値を指定します。
+ **受信者のパブリックキー**
RFC 5280 で定義されているように、(`SubjectPublicKeyInfo`SPKI) とも呼ばれる受信者の DER エンコードされた X.509 パブリックキーを指定する必要があります。 [https://tools.ietf.org/html/rfc5280](https://tools.ietf.org/html/rfc5280)
非対称キーアグリーメント KMS キーペアのパブリックキー、または の外部で生成されたキーペアのパブリックキーを指定できます AWS。
+ **曲線仕様**
指定されたパブリックキーの楕円曲線仕様を識別します。
暗号化時に、キーリングは指定された曲線に新しいキーペアを作成し、新しいプライベートキーと指定されたパブリックキーを使用して共有ラッピングキーを取得します。
有効な値: `ECC_NIST_P256`、`ECC_NIS_P384`、`ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
次の例では、キーアグリーメントスキーマを使用して Raw ECDH `EphemeralPrivateKeyToStaticPublicKey`キーリングを作成します。暗号化時に、キーリングは指定された`ECC_NIST_P256`曲線に新しいキーペアをローカルに作成します。
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH ephemeral keyring
var ephemeralConfiguration = new RawEcdhStaticConfigurations()
{
EphemeralPrivateKeyToStaticPublicKey = new EphemeralPrivateKeyToStaticPublicKeyInput
{
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = ephemeralConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
次の例では、キーアグリーメントスキーマを使用して Raw ECDH `EphemeralPrivateKeyToStaticPublicKey`キーリングを作成します。暗号化時に、キーリングは指定された`ECC_NIST_P256`曲線に新しいキーペアをローカルに作成します。
```
private static void EphemeralRawEcdhKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
ByteBuffer recipientPublicKey = getPublicKeyBytes();
// Create the Raw ECDH ephemeral keyring
final CreateRawEcdhKeyringInput ephemeralInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.EphemeralPrivateKeyToStaticPublicKey(
EphemeralPrivateKeyToStaticPublicKeyInput.builder()
.recipientPublicKey(recipientPublicKey)
.build()
)
.build()
).build();
final IKeyring ephemeralKeyring = materialProviders.CreateRawEcdhKeyring(ephemeralInput);
}
```
------
#### [ Rust ]
次の例では、キーアグリーメントスキーマを使用して Raw ECDH `ephemeral_raw_ecdh_static_configuration`キーリングを作成します。暗号化時に、キーリングは指定された曲線に新しいキーペアをローカルに作成します。
```
// Create EphemeralPrivateKeyToStaticPublicKeyInput
let ephemeral_raw_ecdh_static_configuration_input =
EphemeralPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let ephemeral_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::EphemeralPrivateKeyToStaticPublicKey(ephemeral_raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH ephemeral private key keyring
let ephemeral_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(ephemeral_raw_ecdh_static_configuration)
.send()
.await?;
```
------
### PublicKeyDiscovery
復号するときは、 AWS Database Encryption SDK が使用できるラッピングキーを指定するのがベストプラクティスです。このベストプラクティスに従うには、送信者のプライベートキーと受信者のパブリックキーの両方を指定する ECDH キーリングを使用します。ただし、Raw ECDH 検出キーリング、つまり、指定されたキーのパブリックキーが暗号化されたレコードのマテリアル説明フィールドに保存されている受信者のパブリックキーと一致するレコードを復号できる Raw ECDH キーリングを作成することもできます。このキーアグリーメントスキーマはレコードのみを復号できます。
**重要**
`PublicKeyDiscovery` キーアグリーメントスキーマを使用してレコードを復号する場合、所有者に関係なく、すべてのパブリックキーを受け入れます。
`PublicKeyDiscovery` キーアグリーメントスキーマを使用して Raw ECDH キーリングを初期化するには、次の値を指定します。
+ **受信者の静的プライベートキー**
[RFC 595](https://tools.ietf.org/html/rfc5958#section-2)8 で定義されているように、受信者の PEM エンコードされたプライベートキー (PKCS \$18 PrivateKeyInfo 構造) を指定する必要があります。
+ **曲線仕様**
指定されたプライベートキーの楕円曲線仕様を識別します。送信者と受信者の両方のキーペアには、同じ曲線仕様が必要です。
有効な値: `ECC_NIST_P256`、`ECC_NIS_P384`、`ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
次の例では、キーアグリーメントスキーマを使用して Raw ECDH `PublicKeyDiscovery`キーリングを作成します。このキーリングは、指定されたプライベートキーのパブリックキーが、暗号化されたレコードのマテリアル説明フィールドに保存されている受信者のパブリックキーと一致するレコードを復号できます。
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePrivateKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH discovery keyring
var discoveryConfiguration = new RawEcdhStaticConfigurations()
{
PublicKeyDiscovery = new PublicKeyDiscoveryInput
{
RecipientStaticPrivateKey = AlicePrivateKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
次の例では、キーアグリーメントスキーマを使用して Raw ECDH `PublicKeyDiscovery`キーリングを作成します。このキーリングは、指定されたプライベートキーのパブリックキーが、暗号化されたレコードのマテリアル説明フィールドに保存されている受信者のパブリックキーと一致するレコードを復号できます。
```
private static void RawEcdhDiscovery() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH discovery keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.PublicKeyDiscovery(
PublicKeyDiscoveryInput.builder()
// Must be a PEM-encoded private key
.recipientStaticPrivateKey(ByteBuffer.wrap(sender.getPrivate().getEncoded()))
.build()
)
.build()
).build();
final IKeyring publicKeyDiscovery = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
次の の例では、キーアグリーメントスキーマを使用して Raw ECDH `discovery_raw_ecdh_static_configuration`キーリングを作成します。このキーリングは、指定されたプライベートキーのパブリックキーがメッセージ暗号文に保存されている受信者のパブリックキーと一致するメッセージを復号できます。
```
// Create PublicKeyDiscoveryInput
let discovery_raw_ecdh_static_configuration_input =
PublicKeyDiscoveryInput::builder()
// Must be a UTF8 PEM-encoded private key
.recipient_static_private_key(private_key_recipient_utf8_bytes)
.build()?;
let discovery_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::PublicKeyDiscovery(discovery_raw_ecdh_static_configuration_input);
// Create raw ECDH discovery private key keyring
let discovery_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(discovery_raw_ecdh_static_configuration)
.send()
.await?;
```
------
# マルチキーリング
****
| |
| --- |
| クライアント側の暗号化ライブラリの名前が AWS Database Encryption SDK に変更されました。このデベロッパーガイドでは、引き続き [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md) に関する情報を提供します。 |
キーリングは組み合わせてマルチキーリングにすることができます。*マルチキーリング*は、種類に関係なく、1 つ以上の個別のキーリングで構成されるキーリングです。一連のキーリングを複数使用した場合のように動作します。マルチキーリングを使用してデータを暗号化する場合は、そのキーリングに含まれる任意のラッピングキーを使用してそのデータを復号できます。
マルチキーリングを作成してデータを暗号化する場合は、いずれかのキーリングを*ジェネレーターキーリング*に指定します。他のすべてのキーリングは、*子キーリング*と呼ばれます。ジェネレーターキーリングは、プレーンテキストのデータキーを生成して暗号化します。その後、すべての子キーリングのすべてのラッピングキーによって、そのプレーンテキストデータキーが暗号化されます。マルチキーリングは、プレーンテキストのキーと、マルチキーリングのラッピングキーごとに 1 つの暗号化されたデータキーを返します。ジェネレーターキーリングが [KMS キーリング](use-kms-keyring.md)の場合、 AWS KMS キーリングのジェネレーターキーはプレーンテキストキーを生成して暗号化します。次に、 AWS KMS キーリング AWS KMS keys のすべての追加キーと、マルチキーリングのすべての子キーリングのすべてのラッピングキーは、同じプレーンテキストキーを暗号化します。
復号時に、 AWS Database Encryption SDK はキーリングを使用して、暗号化されたデータキーの 1 つを復号しようとします。キーリングは、マルチキーリングで指定された順番で呼び出されます。暗号化されたデータキーがキーリングの任意のキーによって復号されると、処理は停止されます。
マルチキーリングを作成するにはまず、子キーリングをインスタンス化します。この例では、 AWS KMS キーリングと Raw AES キーリングを使用しますが、サポートされている任意のキーリングをマルチキーリングに結合できます。
------
#### [ Java ]
```
// 1. Create the raw AES keyring.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawAesKeyringInput createRawAesKeyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// 1. Create the raw AES keyring.
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createRawAesKeyringInput = new CreateRawAesKeyringInput
{
KeyName = "keyName",
KeyNamespace = "myNamespaces",
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
// We create a MRK multi keyring, as this interface also supports
// single-region KMS keys,
// and creates the KMS client for us automatically.
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = keyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
// 1. Create the raw AES keyring
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
// 2. Create the AWS KMS keyring
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(key_arn)
.send()
.await?;
```
------
次に、マルチキーリングを作成し、ジェネレーターキーリングがある場合はそれを指定します。この例では、キーリングが AWS KMS ジェネレーターキーリング、AES キーリングが子キーリングであるマルチキーリングを作成します。
------
#### [ Java ]
Java コン`CreateMultiKeyringInput`ストラクタを使用すると、ジェネレーターキーリングと子キーリングを定義できます。結果 `createMultiKeyringInput` のオブジェクトは不変です。
```
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(awsKmsMrkMultiKeyring)
.childKeyrings(Collections.singletonList(rawAesKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
.NET `CreateMultiKeyringInput` コンストラクターでは、ジェネレータキーリングと子キーリングを定義できます。結果 `CreateMultiKeyringInput` のオブジェクトは不変です。
```
var createMultiKeyringInput = new CreateMultiKeyringInput
{
Generator = awsKmsMrkMultiKeyring,
ChildKeyrings = new List { rawAesKeyring }
};
var multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ Rust ]
```
let multi_keyring = mpl
.create_multi_keyring()
.generator(aws_kms_mrk_multi_keyring)
.child_keyrings(vec![raw_aes_keyring.clone()])
.send()
.await?;
```
------
これで、データの暗号化と復号にマルチキーリングを使用できます。