翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# AWS KMS キーリング
AWS KMS キーリングは、 [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 キーを使用するキーリングをサポートします。以下のプログラミング言語の実装では、非対称 RSA KMS AWS KMS キーを使用するキーリングもサポートされています。
+ のバージョン 3.*x* AWS Encryption SDK for Java
+ AWS Encryption SDK for .NET のバージョン 4.*x* 以降
+ オプションの [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) 依存関係とともに AWS Encryption SDK for Python使用する場合、 のバージョン 4.*x*。
+ AWS Encryption SDK for Rust のバージョン 1.*x*
+ AWS Encryption SDK for Go のバージョン 0.1.*x* 以降
他の言語実装の暗号化キーリングに非対称 KMS キーを含めようとすると、暗号化呼び出しは失敗します。復号キーリングに含めても無視されます。
マルチ AWS KMS リージョンキーは、 [のバージョン 2.3.*x*](about-versions.md#version2.3) AWS Encryption SDK および AWS Encryption CLI のバージョン 3.0.*x* 以降、 AWS KMS キーリングまたはマスターキープロバイダーで使用できます。multi-Region-awareシンボルの使用の詳細と例については、「」を参照してください[マルチリージョンの使用 AWS KMS keys](configure.md#config-mrks)。マルチリージョンキーの詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[マルチリージョンキーを使用する](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)」を参照してください。
**注記**
の *KMS キーリングに関するすべての言及*は AWS Encryption SDK AWS KMS 、キーリングを指します。
AWS KMS キーリングには、次の 2 種類のラッピングキーを含めることができます。
+ **ジェネレーターキー**: プレーンテキストのデータキーを生成し、暗号化します。データを暗号化するキーリングには、ジェネレーターキーが 1 つ必要です。
+ **追加キー**: ジェネレーターキーが生成したプレーンテキストのデータキーを暗号化します。 AWS KMS キーリングには 0 個以上の追加キーを含めることができます。
メッセージを暗号化するには、 にジェネレーターキーが必要です。 AWS KMS キーリングに 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-encrypt)
+ [AWS KMS 検出キーリングの使用](#kms-keyring-discovery)
+ [AWS KMS リージョン検出キーリングの使用](#kms-keyring-regional)
## AWS KMS キーリングに必要なアクセス許可
AWS 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 デベロッパーガイド*」の[「KMS キーのアクセスとアクセス許可](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 Encryption SDK for C、[キー ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) または[エイリアス ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN) を使用して 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) を使用してデータを暗号化できます。
+ 復号キーリングでは、キー ARN を使用して AWS KMS keysを指定する必要があります。この要件は、 AWS Encryption SDKのすべての言語の実装に適用されます。詳細については、「[ラッピングキーの選択](configure.md#config-keys)」を参照してください。
+ 暗号化および復号に使用するキーリングでは、キー ARN を使用して AWS KMS keysを指定する必要があります。この要件は、 AWS Encryption SDKのすべての言語の実装に適用されます。
暗号化キーリングで KMS キーのエイリアス名またはエイリアス ARN を指定すると、暗号化オペレーションによって、現在エイリアスに関連付けられているキー ARN が、暗号化されたデータキーのメタデータに保存されます。エイリアスは保存されません。エイリアスの変更は、暗号化されたデータキーの復号に使用される KMS キーには影響しません。
## AWS KMS キーリングの作成
各 AWS KMS キーリングは、同じ AWS KMS key または異なる AWS アカウント および AWS KMS keys の 1 つまたは複数の で設定できます AWS リージョン。は、対称暗号化 KMS キー (SYMMETRIC\$1DEFAULT) または非対称 RSA KMS キー AWS KMS keys である必要があります。対称暗号化[マルチリージョン KMS キー](configure.md#config-mrks)を使用することもできます。[マルチキーリング](use-multi-keyring.md)では 1 つ以上の AWS KMS キーリングを使用できます。
データを暗号化および復号する 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)と呼ばれます）。
以外の AWS Encryption SDK 言語実装では AWS Encryption SDK for C、暗号化キーリングまたはマルチキーリングのすべてのラッピングキーがデータキーを暗号化できる必要があります。いずれかのラッピングキーが暗号化に失敗すると、暗号化メソッドは失敗します。そのため、呼び出し元は、キーリング内のすべてのキーについて[必要な許可](#kms-keyring-permissions)を持っている必要があります。検出キーリングを使用して、単独またはマルチキーリングでデータを暗号化すると、暗号化操作は失敗します。例外は です。 AWS Encryption SDK for C暗号化オペレーションは標準検出キーリングを無視しますが、マルチリージョン検出キーリングを単独で指定するか、マルチキーリングで指定すると失敗します。
次の例では、ジェネレーター AWS KMS キーと 1 つの追加キーを使用して キーリングを作成します。ジェネレーターキーと追加キーはどちらも対称暗号化 KMS キーです。これらの例では、[キー ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) を使用して KMS キーを識別します。これは、暗号化に使用される AWS KMS キーリングのベストプラクティスであり、復号に使用される AWS KMS キーリングの要件です。詳細については、「[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)」を参照してください。
------
#### [ C ]
AWS KMS key の暗号化キーリングで を識別するには AWS Encryption SDK for C、[キー ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) または[エイリアス ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) を指定します。復号キーリングでは、キー ARN を使用する必要があります。詳細については、「[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)」を参照してください。
詳しい例については、[string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp) を参照してください。
```
const char * generator_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
const char * additional_key = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
struct aws_cryptosdk_keyring *kms_encrypt_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(generator_key,{additional_key});
```
------
#### [ C\$1 / .NET ]
for .NET で 1 つ以上の KMS AWS Encryption SDK キーを持つキーリングを作成するには、 `CreateAwsKmsMultiKeyring()`メソッドを使用します。この例では AWS KMS キーを 2 つ使用しています。1 つの KMS キーを指定するには、`Generator` パラメータのみを使用します。追加の KMS キーを指定する `KmsKeyIds` パラメータはオプションです。
このキーリングの入力は AWS KMS クライアントを取りません。代わりに、 はキーリングの KMS キーで表されるリージョンごとにデフォルトの AWS KMS クライアント AWS Encryption SDK を使用します。たとえば、 `Generator`パラメータの値で識別される KMS キーが米国西部 (オレゴン) リージョン (`us-west-2`) にある場合、 は`us-west-2`リージョンのデフォルト AWS KMS クライアント AWS Encryption SDK を作成します。 AWS KMS クライアントをカスタマイズする必要がある場合は、`CreateAwsKmsKeyring()` メソッドを使用します。
.NET AWS KMS key の で暗号化キーリング AWS Encryption SDK に を指定する場合、[キー 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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、.NET AWS Encryption SDK 用 のバージョン 4.*x* と `CreateAwsKmsKeyring()`メソッドを使用して AWS KMS クライアントをカスタマイズします。
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
string generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List additionalKeys = new List { "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321" };
// Instantiate the keyring input object
var createEncryptKeyringInput = new CreateAwsKmsMultiKeyringInput
{
Generator = generatorKey,
KmsKeyIds = additionalKeys
};
var kmsEncryptKeyring = mpl.CreateAwsKmsMultiKeyring(createEncryptKeyringInput);
```
------
#### [ JavaScript Browser ]
で暗号化キーリング AWS KMS key に を指定する場合 AWS Encryption SDK for JavaScript、[キー 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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
完全な例については、GitHub の AWS Encryption SDK for JavaScript リポジトリの[「kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/kms_simple.ts)」を参照してください。
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'
const keyring = new KmsKeyringBrowser({
clientProvider,
generatorKeyId,
keyIds: [additionalKey]
})
```
------
#### [ JavaScript Node.js ]
で暗号化キーリング AWS KMS key に を指定すると AWS Encryption SDK for JavaScript、[キー 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](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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
完全な例については、GitHub の AWS Encryption SDK for JavaScript リポジトリの[「kms\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_simple.ts)」を参照してください。
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
const additionalKey = 'alias/exampleAlias'
const keyring = new KmsKeyringNode({
generatorKeyId,
keyIds: [additionalKey]
})
```
------
#### [ Java ]
1 つ以上のキーを使用して AWS KMS キーリングを作成するには、 `CreateAwsKmsMultiKeyring()`メソッドを使用します。この例では、2 つの KMS キーを使用します。1 つの KMS キーを指定するには、`generator` パラメータのみを使用します。追加の KMS キーを指定する `kmsKeyIds` パラメータはオプションです。
このキーリングの入力は AWS KMS クライアントを取りません。代わりに、 はキーリングの KMS キーで表されるリージョンごとにデフォルトの AWS KMS クライアント AWS Encryption SDK を使用します。たとえば、 `Generator`パラメータの値で識別される KMS キーが米国西部 (オレゴン) リージョン (`us-west-2`) にある場合、 は`us-west-2`リージョンのデフォルト AWS KMS クライアント AWS Encryption SDK を作成します。 AWS KMS クライアントをカスタマイズする必要がある場合は、`CreateAwsKmsKeyring()` メソッドを使用します。
で暗号化キーリング AWS KMS key に を指定する場合 AWS Encryption SDK for Java、[キー 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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
完全な例については、GitHub のリポジトリの AWS Encryption SDK for Java [BasicEncryptionKeyringExample.java](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/keyrings/BasicEncryptionKeyringExample.java)」を参照してください。
```
// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder().build();
final MaterialProviders materialProviders = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
String generatorKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
List additionalKey = Collections.singletonList("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the keyring
final CreateAwsKmsMultiKeyringInput keyringInput = CreateAwsKmsMultiKeyringInput.builder()
.generator(generatorKey)
.kmsKeyIds(additionalKey)
.build();
final IKeyring kmsKeyring = materialProviders.CreateAwsKmsMultiKeyring(keyringInput);
```
------
#### [ Python ]
1 つ以上のキーを使用して AWS KMS キーリングを作成するには、 `create_aws_kms_multi_keyring()`メソッドを使用します。この例では、2 つの KMS キーを使用します。1 つの KMS キーを指定するには、`generator` パラメータのみを使用します。追加の KMS キーを指定する `kms_key_ids` パラメータはオプションです。
このキーリングの入力は AWS KMS クライアントを取りません。代わりに、 はキーリングの KMS キーで表されるリージョンごとにデフォルトの AWS KMS クライアント AWS Encryption SDK を使用します。たとえば、 `generator`パラメータの値で識別される KMS キーが米国西部 (オレゴン) リージョン (`us-west-2`) にある場合、 は`us-west-2`リージョンのデフォルト AWS KMS クライアント AWS Encryption SDK を作成します。 AWS KMS クライアントをカスタマイズする必要がある場合は、`create_aws_kms_keyring()` メソッドを使用します。
で暗号化キーリング AWS KMS key に を指定すると AWS Encryption SDK for Python、[キー 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](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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、[デフォルトのコミットメントポリシー](migrate-commitment-policy.md) を使用して AWS Encryption SDK クライアントをインスタンス化します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。完全な例については、GitHub の AWS Encryption SDK for Python リポジトリの[「aws\$1kms\$1multi\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/aws_kms_multi_keyring_example.py)」を参照してください。
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS keyring
kms_multi_keyring_input: CreateAwsKmsMultiKeyringInput = CreateAwsKmsMultiKeyringInput(
generator="arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
kms_key_ids="arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
)
kms_multi_keyring: IKeyring = mat_prov.create_aws_kms_multi_keyring(
input=kms_multi_keyring_input
)
```
------
#### [ Rust ]
1 つ以上のキーを使用して AWS KMS キーリングを作成するには、 `create_aws_kms_multi_keyring()`メソッドを使用します。この例では、2 つの KMS キーを使用します。1 つの KMS キーを指定するには、`generator` パラメータのみを使用します。追加の KMS キーを指定する `kms_key_ids` パラメータはオプションです。
このキーリングの入力は AWS KMS クライアントを取りません。代わりに、 はキーリングの KMS キーで表されるリージョンごとにデフォルトの AWS KMS クライアント AWS Encryption SDK を使用します。たとえば、 `generator`パラメータの値で識別される KMS キーが米国西部 (オレゴン) リージョン (`us-west-2`) にある場合、 は`us-west-2`リージョンのデフォルト AWS KMS クライアント AWS Encryption SDK を作成します。 AWS KMS クライアントをカスタマイズする必要がある場合は、`create_aws_kms_keyring()` メソッドを使用します。
for Rust で AWS KMS key 暗号化キーリング AWS Encryption SDK に を指定する場合、[キー 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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、[デフォルトのコミットメントポリシー](migrate-commitment-policy.md) を使用して AWS Encryption SDK クライアントをインスタンス化します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。完全な例については、GitHub の [aws-encryption-sdk リポジトリの Rust ディレクトリの aws\$1kms\$1keyring\$1example.rs](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/keyring/aws_kms_keyring_example.rs) を参照してください。 aws-encryption-sdk
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create the AWS KMS keyring
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
kms_multi_keyring: IKeyring = mpl.create_aws_kms_multi_keyring(
input=kms_multi_keyring_input
)
```
------
#### [ Go ]
1 つ以上のキーを使用して AWS KMS キーリングを作成するには、 `create_aws_kms_multi_keyring()`メソッドを使用します。この例では、2 つの KMS キーを使用します。1 つの KMS キーを指定するには、`generator` パラメータのみを使用します。追加の KMS キーを指定する `kms_key_ids` パラメータはオプションです。
このキーリングの入力は AWS KMS クライアントを取りません。代わりに、 はキーリングの KMS キーで表されるリージョンごとにデフォルトの AWS KMS クライアント AWS Encryption SDK を使用します。たとえば、 `generator`パラメータの値で識別される KMS キーが米国西部 (オレゴン) リージョン (`us-west-2`) にある場合、 は`us-west-2`リージョンのデフォルト AWS KMS クライアント AWS Encryption SDK を作成します。 AWS KMS クライアントをカスタマイズする必要がある場合は、`create_aws_kms_keyring()` メソッドを使用します。
for Go で AWS KMS key 暗号化キーリング AWS Encryption SDK に を指定する場合、[キー 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) などの有効なキー識別子を使用できます。 AWS KMS キーリング AWS KMS keys で を識別する方法については、「」を参照してください[AWS KMS キーリング AWS KMS keys での の識別](#kms-keyring-id)。
次の例では、[デフォルトのコミットメントポリシー](migrate-commitment-policy.md) を使用して AWS Encryption SDK クライアントをインスタンス化します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create the AWS KMS keyring
awsKmsMultiKeyringInput := mpltypes.CreateAwsKmsMultiKeyringInput{
Generator: "&arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
KmsKeyIds: []string{"arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"},
}
awsKmsMultiKeyring, err := matProv.CreateAwsKmsMultiKeyring(context.Background(), awsKmsMultiKeyringInput)
```
------
は、非対称 RSA KMS AWS KMS キーを使用するキーリング AWS Encryption SDK もサポートしています。非対称 RSA AWS KMS キーリングに含めることができるキーペアは 1 つだけです。
非対称 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) アクセス許可が必要です。
**注記**
非対称 RSA KMS AWS KMS キーを使用する キーリングを作成するには、次のいずれかのプログラミング言語実装を使用する必要があります。
のバージョン 3.*x* AWS Encryption SDK for Java
AWS Encryption SDK for .NET のバージョン 4.*x* 以降
オプションの [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) 依存関係とともに使用する場合の AWS Encryption SDK for Pythonのバージョン 4.*x*。
AWS Encryption SDK for Rust のバージョン 1.*x*
AWS Encryption SDK for Go のバージョン 0.1.*x* 以降
次の例では、 `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`
------
#### [ C\$1 / .NET ]
非対称 RSA AWS KMS キーリングを作成するには、非対称 RSA KMS キーからパブリックキーとプライベートキー ARN を指定する必要があります。パブリックキーは PEM でエンコードされている必要があります。次の例では、非対称 RSA AWS KMS キーペアを使用して キーリングを作成します。
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
var publicKey = new MemoryStream(Encoding.UTF8.GetBytes(AWS KMS RSA public key));
// Instantiate the keyring input object
var createKeyringInput = new CreateAwsKmsRsaKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = AWS KMS RSA private key ARN,
PublicKey = publicKey,
EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};
// Create the keyring
var kmsRsaKeyring = mpl.CreateAwsKmsRsaKeyring(createKeyringInput);
```
------
#### [ Java ]
非対称 RSA AWS KMS キーリングを作成するには、非対称 RSA KMS キーからパブリックキーとプライベートキー ARN を指定する必要があります。パブリックキーは PEM でエンコードされている必要があります。次の例では、非対称 RSA AWS KMS キーペアを使用して キーリングを作成します。
```
// Instantiate the AWS Encryption SDK and material providers
final AwsCrypto crypto = AwsCrypto.builder()
// Specify algorithmSuite without asymmetric signing here
//
// ALG_AES_128_GCM_IV12_TAG16_NO_KDF("0x0014"),
// ALG_AES_192_GCM_IV12_TAG16_NO_KDF("0x0046"),
// ALG_AES_256_GCM_IV12_TAG16_NO_KDF("0x0078"),
// ALG_AES_128_GCM_IV12_TAG16_HKDF_SHA256("0x0114"),
// ALG_AES_192_GCM_IV12_TAG16_HKDF_SHA256("0x0146"),
// ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256("0x0178")
.withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_IV12_TAG16_HKDF_SHA256)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a KMS RSA keyring.
// This keyring takes in:
// - kmsClient
// - kmsKeyId: Must be an ARN representing an asymmetric RSA KMS key
// - publicKey: A ByteBuffer of a UTF-8 encoded PEM file representing the public
// key for the key passed into kmsKeyId
// - encryptionAlgorithm: Must be either RSAES_OAEP_SHA_256 or RSAES_OAEP_SHA_1
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
CreateAwsKmsRsaKeyringInput.builder()
.kmsClient(KmsClient.create())
.kmsKeyId(rsaKeyArn)
.publicKey(publicKey)
.encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
.build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ Python ]
非対称 RSA AWS KMS キーリングを作成するには、非対称 RSA KMS キーからパブリックキーとプライベートキー ARN を指定する必要があります。パブリックキーは PEM でエンコードされている必要があります。次の例では、非対称 RSA AWS KMS キーペアを使用して キーリングを作成します。
```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS keyring
keyring_input: CreateAwsKmsRsaKeyringInput = CreateAwsKmsRsaKeyringInput(
public_key="public_key",
kms_key_id="kms_key_id",
encryption_algorithm="RSAES_OAEP_SHA_256",
kms_client=kms_client
)
kms_rsa_keyring: IKeyring = mat_prov.create_aws_kms_rsa_keyring(
input=keyring_input
)
```
------
#### [ Rust ]
非対称 RSA AWS KMS キーリングを作成するには、非対称 RSA KMS キーからパブリックキーとプライベートキー ARN を指定する必要があります。パブリックキーは PEM でエンコードされている必要があります。次の例では、非対称 RSA AWS KMS キーペアを使用して キーリングを作成します。
```
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create an AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create the AWS KMS keyring
let kms_rsa_keyring = mpl
.create_aws_kms_rsa_keyring()
.kms_key_id(kms_key_id)
.public_key(aws_smithy_types::Blob::new(public_key))
.encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
.kms_client(kms_client)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create the AWS KMS keyring
awsKmsRSAKeyringInput := mpltypes.CreateAwsKmsRsaKeyringInput{
KmsClient: kmsClient,
KmsKeyId: kmsKeyID,
PublicKey: kmsPublicKey,
EncryptionAlgorithm: kmstypes.EncryptionAlgorithmSpecRsaesOaepSha256,
}
awsKmsRSAKeyring, err := matProv.CreateAwsKmsRsaKeyring(context.Background(), awsKmsRSAKeyringInput)
if err != nil {
panic(err)
}
```
------
## AWS KMS 検出キーリングの使用
復号するときは、 で使用できるラッピングキーを指定するのが[ベストプラクティス](best-practices.md)です AWS Encryption SDK 。このベストプラクティスに従うには、ラ AWS KMS ッピングキーを指定したキーに制限する復 AWS KMS 号キーリングを使用します。ただし、*AWS KMS 検出キーリング*、つまりラッピングキーを指定しない AWS KMS キーリングを作成することもできます。
AWS Encryption SDK には、標準の AWS KMS 検出キーリングと、 AWS KMS マルチリージョンキー用の検出キーリングが用意されています。 AWS Encryption SDKでのマルチリージョンキーの使用の詳細については、「[マルチリージョンの使用 AWS KMS keys](configure.md#config-mrks)」を参照してください。
ラッピングキーが指定されていないため、検出キーリングではデータを暗号化することはできません。検出キーリングを使用して、単独またはマルチキーリングでデータを暗号化すると、暗号化操作は失敗します。例外は です。 AWS Encryption SDK for C暗号化オペレーションでは標準検出キーリングは無視されますが、マルチリージョン検出キーリングを単独で指定するか、マルチキーリングで指定すると失敗します。
復号時に、検出キーリングを使用すると、 AWS Encryption SDK は、暗号化されたデータキーを所有またはアクセスできるユーザーに関係なく、暗号化されたデータキーを暗号化 AWS KMS key された を使用して復号するように AWS KMS に要求できます AWS KMS key。呼び出しは、呼び出し元にその AWS KMS keyに対する `kms:Decrypt` 許可がある場合にのみ成功します。
**重要**
復号マルチキーリングに AWS KMS 検出[キーリング](use-multi-keyring.md)を含めると、検出キーリングは、マルチキーリングの他のキーリングで指定されたすべての KMS キー制限を上書きします。マルチキーリングは、最も制限の少ないキーリングのように動作します。 AWS KMS 検出キーリングは、単独で使用する場合も、マルチキーリングで使用する場合も、暗号化には影響しません。
AWS Encryption SDK には、便利な AWS KMS 検出キーリングが用意されています。ただし、次の理由から、可能な限り制限されたキーリングを使用することをお勧めします。
+ **真正性** – AWS KMS 検出キーリングは、暗号化 AWS KMS key されたメッセージ内のデータキーの暗号化に使用された任意の を使用できるため、呼び出し元には復号に使用するアクセス許可が付与されます AWS KMS key 。これは、発信者 AWS KMS key が使用する ではない場合があります。たとえば、暗号化されたデータキーの 1 つが、誰でも使用できる安全性 AWS KMS key の低い で暗号化されている可能性があります。
+ **レイテンシーとパフォーマンス** – AWS KMS 検出キーリングは、他の AWS アカウント およびリージョン AWS KMS keys の によって暗号化されたデータキーを含む、暗号化されたすべてのデータキーを復号 AWS Encryption SDK しようとし、呼び出し AWS KMS keys 元に復号に使用するアクセス許可がないため、他のキーリングよりも明らかに遅くなる可能性があります。
検出キーリングを使用する場合は、[*検出フィルター*](configure.md#config-discovery)を使用して、指定 AWS アカウント および[パーティション](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)で使用できる KMS キーを制限することをお勧めします。検出フィルターは、 AWS Encryption SDKのバージョン 1.7.x 以降でサポートされています。アカウント 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 Encryption SDK 使用できる KMS キーを`aws`パーティションおよび 111122223333 サンプルアカウントのキーに制限する検出フィルターを使用して、 AWS KMS 検出キーリングをインスタンス化します。
このコードを使用する前に、例 AWS アカウント とパーティションの値を AWS アカウント および パーティションの有効な値に置き換えます。KMS キーが中国リージョンにある場合は、`aws-cn` のパーティションの値を使用します。KMS キーが AWS GovCloud (US) Regionsにある場合は、`aws-us-gov` のパーティションの値を使用します。それ以外の AWS リージョンの場合は、`aws` パーティション値を使用してください。
------
#### [ C ]
詳しい例については、[kms\$1discovery.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/kms_discovery.cpp) を参照してください。
```
std::shared_ptr discovery_filter(
KmsKeyring::DiscoveryFilter::Builder("aws")
.AddAccount("111122223333")
.Build());
struct aws_cryptosdk_keyring *kms_discovery_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.BuildDiscovery(discovery_filter));
```
------
#### [ C\$1 / .NET ]
次の例では、.NET 用 AWS Encryption SDK のバージョン 4.x を使用します。
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// In a discovery keyring, you specify an AWS KMS client and a discovery filter,
// but not a AWS KMS key
var kmsDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
DiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
};
var kmsDiscoveryKeyring = mpl.CreateAwsKmsDiscoveryKeyring(kmsDiscoveryKeyringInput);
```
------
#### [ JavaScript Browser ]
JavaScript では、discovery プロパティを明示的に指定する必要があります。
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
```
import {
KmsKeyringBrowser,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-browser'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const keyring = new KmsKeyringBrowser(clientProvider, {
discovery,
discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})
```
------
#### [ JavaScript Node.js ]
JavaScript では、discovery プロパティを明示的に指定する必要があります。
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const discovery = true
const keyring = new KmsKeyringNode({
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: '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);
```
------
#### [ Python ]
```
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS discovery keyring
discovery_keyring_input: CreateAwsKmsDiscoveryKeyringInput = CreateAwsKmsDiscoveryKeyringInput(
kms_client=kms_client,
discovery_filter=DiscoveryFilter(
account_ids=[aws_account_id],
partition="aws"
)
)
discovery_keyring: IKeyring = mat_prov.create_aws_kms_discovery_keyring(
input=discovery_keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create a AWS KMS client.
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.account_ids(vec![aws_account_id.to_string()])
.partition("aws".to_string())
.build()?;
// Create the AWS KMS discovery keyring
let discovery_keyring = mpl
.create_aws_kms_discovery_keyring()
.kms_client(kms_client.clone())
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
AccountIds: []string{kmsKeyAccountID},
Partition: "aws",
}
awsKmsDiscoveryKeyringInput := mpltypes.CreateAwsKmsDiscoveryKeyringInput{
KmsClient: kmsClient,
DiscoveryFilter: &discoveryFilter,
}
awsKmsDiscoveryKeyring, err := matProv.CreateAwsKmsDiscoveryKeyring(context.Background(), awsKmsDiscoveryKeyringInput)
if err != nil {
panic(err)
}
```
------
## AWS KMS リージョン検出キーリングの使用
AWS KMS リージョンレベルの検出キーリングは、KMS キーの ARN を指定しないキーリングです。代わりに、 AWS Encryption SDK は特に KMS キーのみを使用して復号できます AWS リージョン。
AWS KMS リージョン検出キーリングを使用して復号する場合、 は指定された AWS Encryption SDK AWS KMS key の で暗号化された暗号化されたデータキーを復号します AWS リージョン。成功するには、発信者がデータキーを暗号化 AWS リージョン した指定された AWS KMS keys 内の少なくとも 1 つの に対する`kms:Decrypt`アクセス許可を持っている必要があります。
他の検出キーリングと同様に、リージョン検出キーリングは暗号化には影響しません。暗号化されたメッセージを復号する場合にのみ機能します。暗号化と復号に使用されるマルチキーリングでリージョン検出キーリングを使用する場合、そのキーリングは復号化時にのみ有効です。マルチリージョン検出キーリングを単独または複数のキーリングで使用してデータを暗号化すると、暗号化オペレーションは失敗します。
**重要**
復号マルチキーリングに AWS KMS リージョン検出[キーリング](use-multi-keyring.md)を含めると、リージョン検出キーリングは、マルチキーリングの他のキーリングで指定されたすべての KMS キー制限を上書きします。マルチキーリングは、最も制限の少ないキーリングのように動作します。 AWS KMS 検出キーリングは、単独で使用する場合も、マルチキーリングで使用する場合も、暗号化には影響しません。
のリージョン検出キーリングは、指定されたリージョンの KMS キーでのみ復号 AWS Encryption SDK for C を試みます。 AWS Encryption SDK for JavaScript および .NET AWS Encryption SDK で検出キーリングを使用する場合は、 AWS KMS クライアントでリージョンを設定します。これらの AWS Encryption SDK 実装では、リージョン別に KMS キーをフィルタリングしませんが、指定されたリージョン外の KMS キーの復号リクエストは失敗 AWS KMS します。
検出キーリングを使用する場合は、*検出フィルター*を使用して、復号に使用される KMS キーを指定された AWS アカウント および パーティション内のキーに制限することをお勧めします。検出フィルターは、 AWS Encryption SDKのバージョン 1.7.x 以降でサポートされています。
たとえば、次のコードは、検出フィルターを使用して AWS KMS リージョン検出キーリングを作成します。このキーリングは、 AWS Encryption SDK を米国西部 (オレゴン) リージョン (us-west-2) のアカウント 111122223333 の KMS キーに制限します。
------
#### [ C ]
実例でこのキーリングや `create_kms_client` メソッドを表示する方法については、「[kms\$1discovery.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/kms_discovery.cpp)」を参照してください。
```
std::shared_ptr discovery_filter(
KmsKeyring::DiscoveryFilter::Builder("aws")
.AddAccount("111122223333")
.Build());
struct aws_cryptosdk_keyring *kms_regional_keyring = Aws::Cryptosdk::KmsKeyring::Builder()
.WithKmsClient(create_kms_client(Aws::Region::US_WEST_2)).BuildDiscovery(discovery_filter));
```
------
#### [ C\$1 / .NET ]
AWS Encryption SDK for .NET には、専用のリージョン検出キーリングはありません。ただし、復号時に使用する KMS キーを特定のリージョンに制限する手法はいくつかあります。
検出キーリング内のリージョンを制限する最も効率的な方法は、単一リージョンキーのみを使用してデータを暗号化した場合でも、マルチリージョン対応の検出キーリングを使用することです。単一リージョンキーが見つかった場合、マルチリージョン対応キーリングはマルチリージョン機能を使用しません。
`CreateAwsKmsMrkDiscoveryKeyring()` メソッドによって返されるキーリングは、 AWS KMSを呼び出す前に KMS キーをリージョン別にフィルタリングします。暗号化されたデータキーが、 `CreateAwsKmsMrkDiscoveryKeyringInput` オブジェクトの `Region`パラメータで指定されたリージョンの KMS キーによって暗号化された AWS KMS 場合にのみ、復号リクエストを に送信します。
次の例では、.NET 用 AWS Encryption SDK のバージョン 4.x を使用します。
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// Create the discovery filter
var filter = DiscoveryFilter = new DiscoveryFilter
{
AccountIds = account,
Partition = "aws"
};
var regionalDiscoveryKeyringInput = new CreateAwsKmsMrkDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
Region = RegionEndpoint.USWest2,
DiscoveryFilter = filter
};
var kmsRegionalDiscoveryKeyring = mpl.CreateAwsKmsMrkDiscoveryKeyring(regionalDiscoveryKeyringInput);
```
AWS KMS クライアントのインスタンス ([AmazonKeyManagementServiceClient](https://docs.aws.amazon.com/sdkfornet/v4/apidocs/items/KeyManagementService/TKeyManagementServiceClient.html)) でリージョンを指定 AWS リージョン することで、KMS キーを特定の に制限することもできます。ただし、この構成は、マルチリージョン対応の検出キーリングを使用するよりも効率が悪く、コストもかかる可能性があります。を呼び出す前にリージョンごとに KMS キー AWS KMS をフィルタリングする代わりに AWS KMS、 AWS Encryption SDK for .NET は暗号化されたデータキー AWS KMS ごとに (復号されるまで) を呼び出し、 を使用して使用する KMS キーを指定されたリージョンに制限します。
次の例では、.NET 用 AWS Encryption SDK のバージョン 4.x を使用します。
```
// Instantiate the AWS Encryption SDK and material providers
var esdk = new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());
List account = new List { "111122223333" };
// Create the discovery filter,
// but not a AWS KMS key
var createRegionalDiscoveryKeyringInput = new CreateAwsKmsDiscoveryKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(RegionEndpoint.USWest2),
DiscoveryFilter = new DiscoveryFilter()
{
AccountIds = account,
Partition = "aws"
}
};
var kmsRegionalDiscoveryKeyring = mlp.CreateAwsKmsDiscoveryKeyring(createRegionalDiscoveryKeyringInput);
```
------
#### [ JavaScript Browser ]
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const clientProvider = getClient(KMS, { credentials })
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringBrowser(clientProvider, {
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
```
------
#### [ JavaScript Node.js ]
次の例では、 `buildClient`関数を使用してデフォルトの[コミットメントポリシー](migrate-commitment-policy.md) を指定します`REQUIRE_ENCRYPT_REQUIRE_DECRYPT`。を使用して`buildClient`、暗号化されたメッセージ内の暗号化されたデータキーの数を制限することもできます。詳細については、「[暗号化されたデータキーの制限](configure.md#config-limit-keys)」を参照してください。
このキーリングと `limitRegions`関数を実際の例で表示するには、[「kms\$1regional\$1discovery.ts](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-node/src/kms_regional_discovery.ts)」を参照してください。
```
import {
KmsKeyringNode,
buildClient,
CommitmentPolicy,
} from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(
CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
const discovery = true
const clientProvider = limitRegions(['us-west-2'], getKmsClient)
const keyring = new KmsKeyringNode({
clientProvider,
discovery,
discoveryFilter: { accountIDs: ['111122223333'], partition: 'aws' }
})
```
------
#### [ 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);
```
------
#### [ Python ]
```
# Instantiate the AWS Encryption SDK
client = aws_encryption_sdk.EncryptionSDKClient(
commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)
# Create a boto3 client for AWS KMS
kms_client = boto3.client('kms', region_name=aws_region)
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
# Instantiate the material providers
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS regional discovery keyring
regional_discovery_keyring_input: CreateAwsKmsMrkDiscoveryKeyringInput = \
CreateAwsKmsMrkDiscoveryKeyringInput(
kms_client=kms_client,
region=mrk_replica_decrypt_region,
discovery_filter=DiscoveryFilter(
account_ids=[111122223333],
partition="aws"
)
)
regional_discovery_keyring: IKeyring = mat_prov.create_aws_kms_mrk_discovery_keyring(
input=regional_discovery_keyring_input
)
```
------
#### [ Rust ]
```
// Instantiate the AWS Encryption SDK
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Optional: Create an encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create an AWS KMS client
let decrypt_kms_config = aws_sdk_kms::config::Builder::from(&sdk_config)
.region(Region::new(mrk_replica_decrypt_region.clone()))
.build();
let decrypt_kms_client = aws_sdk_kms::Client::from_conf(decrypt_kms_config);
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.account_ids(vec![aws_account_id.to_string()])
.partition("aws".to_string())
.build()?;
// Create the regional discovery keyring
let discovery_keyring = mpl
.create_aws_kms_mrk_discovery_keyring()
.kms_client(decrypt_kms_client)
.region(mrk_replica_decrypt_region)
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
#### [ Go ]
```
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Create discovery filter
discoveryFilter := mpltypes.DiscoveryFilter{
AccountIds: []string{awsAccountID},
Partition: "aws",
}
// Create the regional discovery keyring
awsKmsMrkDiscoveryInput := mpltypes.CreateAwsKmsMrkDiscoveryKeyringInput{
KmsClient: kmsClient,
Region: alternateRegionMrkKeyRegion,
DiscoveryFilter: &discoveryFilter,
}
awsKmsMrkDiscoveryKeyring, err := matProv.CreateAwsKmsMrkDiscoveryKeyring(context.Background(), awsKmsMrkDiscoveryInput)
if err != nil {
panic(err)
}
```
------
は、Node.js とブラウザの `excludeRegions`関数 AWS Encryption SDK for JavaScript もエクスポートします。この関数は、特定の AWS KMS リージョン AWS KMS keys で を省略するリージョン検出キーリングを作成します。次の例では、米国東部 (バージニア北部) (us-east-1) AWS リージョン を除くすべての でアカウント 111122223333 AWS KMS keys で使用できる AWS KMS リージョン検出キーリングを作成します。
には同様の方法 AWS Encryption SDK for C はありませんが、カスタム [ClientSupplier](https://github.com/aws/aws-encryption-sdk-c/blob/master/aws-encryption-sdk-cpp/include/aws/cryptosdk/cpp/kms_keyring.h#L157) を作成することで実装できます。
この例は、Node.js 用のコードを示しています。
```
const discovery = true
const clientProvider = excludeRegions(['us-east-1'], getKmsClient)
const keyring = new KmsKeyringNode({
clientProvider,
discovery,
discoveryFilter: { accountIDs: [111122223333], partition: 'aws' }
})
```