# 暗号化によるデータの保護
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルト暗号化に関するよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
データ保護とは、転送時 (Amazon S3 との間でデータを送受信するとき)と保存時 (Amazon S3 データセンター内のディスクに格納されているとき) にデータを保護することを指します。ハイブリッドポスト量子キー交換やクライアント側の暗号化などの Secure Socket Layer/Transport Layer Security (SSL/TLS) を使用して、転送中のデータを保護できます。Amazon S3 で保管時のデータを保護するには、次のようなオプションがあります。
+ **サーバー側の暗号化** – Amazon S3 は、AWS データセンターのディスクに保存する前にオブジェクトを暗号化し、ダウンロードするときにオブジェクトを復号化します。
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 `PUT` リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を更新できます。
`PUT` リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。
汎用バケットのデフォルトの暗号化設定を変更する方法の詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
バケットのデフォルトの暗号化設定を SSE-KMS に変更しても、バケット内の既存の Amazon S3 オブジェクトの暗号化タイプは変更されません。デフォルトの暗号化設定を SSE-KMS に更新した後に既存のオブジェクトの暗号化タイプを変更するには、Amazon S3 バッチオペレーションを使用できます。S3 バッチオペレーションにオブジェクトのリストを指定すると、バッチオペレーションが対応する API オペレーションを呼び出します。[オブジェクトのコピー](batch-ops-copy-object.md) アクションを使用して既存のオブジェクトをコピーし、SSE-KMS で暗号化されたオブジェクトと同じバケットに書き戻すことができます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」および *AWS Storage Blog* の投稿「[How to retroactively encrypt existing objects in Amazon S3 using S3 Inventory, Amazon Athena, and S3 Batch Operations](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)」を参照してください。
サーバー側の暗号化の詳細については、「[サーバー側の暗号化によるデータの保護](serv-side-encryption.md)」を参照してください。
サーバー側の暗号化を設定するには、以下を参照してください。
+ [Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) の指定](specifying-s3-encryption.md)
+ [AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定](specifying-kms-encryption.md)
+ [AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の指定](specifying-dsse-encryption.md)
+ [お客様が用意したキーによるサーバー側の暗号化 (SSE−C) の指定](specifying-s3-c-encryption.md)
+ **クライアント側の暗号化** – クライアント側でデータを暗号化し、暗号化したデータを Amazon S3 にアップロードします。この場合、暗号化プロセス、暗号化キー、関連ツールはお客様が管理してください。
クライアント側の暗号化を設定するには、[クライアント側の暗号化を使用したデータの保護](UsingClientSideEncryption.md) を参照してください。
ストレージバイトの何パーセントが暗号化されているかを確認するには、Amazon S3 ストレージレンズメトリクスを使用できます。S3 ストレージレンズは、オブジェクトストレージの使用状況とアクティビティを組織全体で可視化するために使用できるクラウドストレージ分析機能です。詳細については、「[S3 Storage Lens を使用したストレージのアクティビティと使用状況の評価](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens?icmpid=docs_s3_user_guide_UsingEncryption.html)」を参照してください。メトリクスの完全なリストについては、「[S3 ストレージレンズメトリクスに関する用語集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens_metrics_glossary.html?icmpid=docs_s3_user_guide_UsingEncryption)」を参照してください。
サーバー側の暗号化、クライアント側の暗号化、転送中の暗号化の詳細については、以下のトピックを参照してください。
**Topics**
+ [
# サーバー側の暗号化によるデータの保護
](serv-side-encryption.md)
+ [
# クライアント側の暗号化を使用したデータの保護
](UsingClientSideEncryption.md)
+ [
# 暗号化を使用して転送中のデータを保護する
](UsingEncryptionInTransit.md)
# サーバー側の暗号化によるデータの保護
**重要**
2026 年 4 月以降、AWS はすべての新しいバケットについて、お客様が用意したキー (SSE-C) によるサーバー側の暗号化を無効にします。さらに、SSE-C 暗号化は、SSE-C 暗号化データを持たない AWS アカウントのすべての既存のバケットに対して無効になります。これらの変更により、SSE-C 暗号化を必要とする少数のアプリケーションは、バケットの作成後に [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API を介して SSE-C の使用を意図的に有効にする必要があります。このような場合、自動化スクリプト、CloudFormation テンプレート、またはその他のインフラストラクチャ設定ツールを更新して、これらの設定を構成する必要がある場合があります。詳細については、[AWS ストレージブログ記事](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/)を参照してください。
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルトの暗号化のよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
サーバー側の暗号化とは、データを受信するアプリケーションまたはサービスによって、送信先でデータを暗号化することです。Amazon S3 は、AWS データセンターのディスクに書き込まれるときにデータをオブジェクトレベルで暗号化し、お客様がデータにアクセスするときに復号します。リクエストが認証され、お客様がアクセス許可を持っていれば、オブジェクトが暗号化されているかどうかに関係なく同じ方法でアクセスできます。例えば、署名付き URL を使用してオブジェクトを共有する場合、その署名付き URL は、オブジェクトが暗号化されているかどうかに関係なく同じように動作します。また、バケット内のオブジェクトを一覧表示すると、リスト API オペレーションは、オブジェクトが暗号化されているかどうかに関係なく、すべてのオブジェクトのリストを返します。
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 `PUT` リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を更新できます。
`PUT` リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。
汎用バケットのデフォルトの暗号化設定を変更する方法の詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
バケットのデフォルトの暗号化設定を SSE-KMS に変更しても、バケット内の既存の Amazon S3 オブジェクトの暗号化タイプは変更されません。デフォルトの暗号化設定を SSE-KMS に更新した後に既存のオブジェクトの暗号化タイプを変更するには、Amazon S3 バッチオペレーションを使用できます。S3 バッチオペレーションにオブジェクトのリストを指定すると、バッチオペレーションが対応する API オペレーションを呼び出します。[オブジェクトのコピー](batch-ops-copy-object.md) アクションを使用して既存のオブジェクトをコピーし、SSE-KMS で暗号化されたオブジェクトと同じバケットに書き戻すことができます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」および *AWS Storage Blog* の投稿「[How to retroactively encrypt existing objects in Amazon S3 using S3 Inventory, Amazon Athena, and S3 Batch Operations](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)」を参照してください。
**注記**
異なる種類のサーバー側暗号化を同時に同じオブジェクトに適用することはできません。
既存のオブジェクトを暗号化する必要がある場合は、S3 バッチオペレーションと S3 インベントリを使用してください。詳細については、「[Encrypting objects with Amazon S3 Batch Operations](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)」(Amazon S3 バッチオペレーションよるオブジェクトの暗号化) および [バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md) を参照してください。
Amazon S3 にデータを保存するとき、サーバー側の暗号化には、暗号化キーの管理方法の選択と適用する暗号化レイヤーの数に応じて、相互に排他的な 4 つのオプションがあります。
**Amazon S3 マネージドキーを用いたサーバー側の暗号化 (SSE-S3)**
すべての Amazon S3 バケットには、デフォルトで暗号化が設定されています。サーバー側の暗号化のデフォルトのオプションは、Amazon S3 マネージド キー (SSE-S3) を使用しています。一意のキーで各オブジェクトを暗号化します。追加の保護措置として、SSE-S3 は定期的にローテーションされるルートキーを使ってキーそのものを暗号化します。SSE-S3 は、利用可能な最強のブロック暗号の 1 つである 256 ビットの 高度暗号化規格 (AES-256) を使用して、データを暗号化します。詳細については、「[Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)](UsingServerSideEncryption.md)」を参照してください。
**AWS Key Management Service (AWS KMS) キー (SSE-KMS) によるサーバー側の暗号化**
AWS KMS keys (SSE-KMS) によるサーバー側の暗号化は、AWS KMS サービスと Amazon S3 の統合によって提供されます。AWS KMS を使用すると、キーをより細かく制御できます。例えば、個別のキーを表示し、制御ポリシーを編集して、AWS CloudTrail のキーに従うことができます。さらに、カスタマーマネージドキーを作成および管理したり、ユーザー、サービス、およびリージョンに固有の AWS マネージドキー を使用したりできます。詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。
**AWS Key Management Service (AWS KMS) キーによる二層式サーバー側の暗号化 (DSSE-KMS)**
AWS KMS keys (DSSE-KMS) による二層式サーバー側の暗号化は SSE-KMS と似ていますが、DSSE-KMS は 1 つのレイヤーではなく 2 つの独立した AES-256 暗号化レイヤーを適用します。最初に AWS KMS データ暗号化キーを使用し、次に別の Amazon S3 マネージド暗号化キーを使用します。両方の暗号化レイヤーがサーバーサイドでオブジェクトに適用されるため、多層暗号化のコンプライアンス要件を満たす暗号化方法を使用しながら、幅広い AWS のサービス とツールを使用して S3 内のデータを分析できます。詳細については、「[AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の使用](UsingDSSEncryption.md)」を参照してください。
**お客様が用意したキーを使用したサーバー側の暗号化 (SSE-C)**
顧客提供キーによるサーバー側の暗号化 (SSE−C) では、お客様が暗号化キーを管理し、Amazon S3 はディスクに書き込む際の暗号化とオブジェクトにアクセスする際の復号を管理します。詳細については、「[お客様が指定したキーによるサーバー側の暗号化 (SSE−C) の使用](ServerSideEncryptionCustomerKeys.md)」を参照してください。
**注記**
S3 アクセスポイントを使用する Amazon FSx ファイルシステムのアクセスポイントを使用する場合、サーバー側の暗号化オプションが 1 つあります。
すべての Amazon FSx ファイルシステムにはデフォルトで暗号化が設定されており、保存時に AWS Key Management Service で管理されるキーを使用して暗号化されます。データは、ファイルシステムに書き込まれ、ファイルシステムから読み取られると、ファイルシステム上で自動的に暗号化および復号されます。これらのプロセスは Amazon FSx によって透過的に処理されます。
# Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルト暗号化に関するよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、オブジェクトは Amazon S3 マネージドキー (SSE-S3) を使用してサーバー側の暗号化により自動的に暗号化されます。この暗号化設定は Amazon S3 バケット内のすべてのオブジェクトに適用されます。
キーローテーションやアクセスポリシーの付与の管理など、キーをより細かく制御する必要がある場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、または AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) を使用できます。KMS キーの編集の詳細については、『*AWS Key Management Service デベロッパーガイド*』の「[キーの編集](https://docs.aws.amazon.com/kms/latest/developerguide/editing-keys.html)」を参照してください。
**注記**
新しいオブジェクトのアップロードを自動的に暗号化するようにバケットを変更しました。以前にデフォルトの暗号化を行わずにバケットを作成した場合、Amazon S3 は SSE-S3 を使用してバケットの暗号化をデフォルトで有効にします。SSE-S3 または SSE-KMS が設定されている既存のバケットについては、デフォルトの暗号化設定は変更されません。SSE-KMS でオブジェクトを暗号化する場合は、バケット設定で暗号化タイプを変更する必要があります。詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。
SSE-KMS でデフォルトの暗号化を使用するようにバケットを設定する場合、S3 バケットキーを有効にして、Amazon S3 から AWS KMS へのリクエストトラフィックを減らし、暗号化のコストを削減することもできます。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
デフォルトの暗号化で SSE-KMS が有効になっているバケットを特定するには、Amazon S3 ストレージレンズメトリクスを使用できます。S3 ストレージレンズは、オブジェクトストレージの使用状況とアクティビティを組織全体で可視化するために使用できるクラウドストレージの分析機能です。詳細については、「[Using S3 Storage Lens to protect your data](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-lens-data-protection.html?icmpid=docs_s3_user_guide_bucket-encryption.html)」(S3 ストレージレンズを使用してデータを保護する) を参照してください。
サーバー側の暗号化を使用すると、Amazon S3 はオブジェクトをディスクに保存する前に暗号化し、オブジェクトをダウンロードするときに復号します。サーバー側の暗号化および暗号化キー管理を使用したデータ保護の詳細については、[サーバー側の暗号化によるデータの保護](serv-side-encryption.md) を参照してください。
デフォルトの暗号化に必要なアクセス許可の詳細については、『*Amazon Simple Storage Service API リファレンス*』の「[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)」を参照してください。
Amazon S3 コンソール、AWS SDK、Amazon S3 REST API、および AWS Command Line Interface (AWS CLI) を使用して、Amazon S3 で S3 バケットのデフォルトの暗号化動作を設定できます。
**既存のオブジェクトの暗号化**
暗号化されていない既存の Amazon S3 オブジェクトを暗号化するには、Amazon S3 バッチオペレーションを使用します。S3 バッチオペレーションは、操作するオブジェクトのリストとともに提供します。バッチオペレーションは各 API を呼び出して、指定されたオペレーションを実行します。[バッチオペレーションのコピーオペレーション](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-copy-object.html)を使用して、既存の暗号化されていないオブジェクトをコピーし、同じバケットに新しい暗号化されたオブジェクトを書き込めます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md) および*AWS ストレージブログ*の投稿である [Amazon S3 バッチオペレーションによるオブジェクトの暗号化](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)を参照してください。
`CopyObject` API オペレーションまたは `copy-object` AWS CLI コマンドを使用して、既存のオブジェクトを暗号化することもできます。詳細については、*AWS ストレージブログ*の投稿である [AWS CLI を使用した既存の Amazon S3 オブジェクトの暗号化](https://aws.amazon.com/blogs/storage/encrypting-existing-amazon-s3-objects-with-the-aws-cli/)を参照してください。
**注記**
デフォルトの暗号化が SSE-KMS に設定されている Amazon S3 バケットは、[サーバーアクセスログによるリクエストのログ記録](ServerLogs.md) の送信先バケットとしては使用できません。サーバーアクセスログの送信先バケットは、デフォルトの暗号化として SSE-S3 のみをサポートしています。
## クロスアカウント操作での SSE-KMS 暗号化の使用
クロスアカウント操作で暗号化を使用する場合は、次の点に注意してください。
+ AWS KMS key Amazon リソースネーム (ARN) またはエイリアスがリクエスト時またはバケットのデフォルト暗号化設定によって提供されない場合は、AWS マネージドキー (`aws/s3`) が使用されます。
+ KMS キーと同じ AWS アカウント の AWS Identity and Access Management (IAM) プリンシパルを使用して S3 オブジェクトをアップロードまたはアクセスする場合は、AWS マネージドキー (`aws/s3`) を使用できます。
+ S3 オブジェクトにクロスアカウントアクセスを許可する場合は、カスタマーマネージドキーを使用します。カスタマーマネージドキーのポリシーを設定して、別のアカウントからのアクセスを許可することができます。
+ カスタマーマネージド KMS キーを指定している場合、完全修飾 KMS キー ARN を使用することをお勧めします。代わりに KMS キーエイリアスを使用する場合、AWS KMS はリクエスタのアカウント内でキーを解決します。この動作により、バケット所有者ではなく、リクエスタに属する KMS キーでデータが暗号化される可能性があります。
+ お客様 (リクエスタ) が `Encrypt` アクセス許可を付与されているキーを指定する必要があります。詳細については、*AWS Key Management Service デベロッパーガイド*の「[キーユーザーが暗号化オペレーションに KMS キーを使用することを許可する](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-users-crypto)」を参照してください。
カスタマーマネージドキーと AWS マネージド KMS キーをどのような場合に使用するかの詳細については、「[Amazon S3 にあるオブジェクトの暗号化に AWS マネージドキー、またはカスタマーマネージドキーを使うべきですか](https://aws.amazon.com/premiumsupport/knowledge-center/s3-object-encryption-keys/)」を参照してください。
## レプリケーションでのデフォルト暗号化の使用
レプリケーション先バケットのデフォルトの暗号化を有効にすると、以下の暗号化動作が適用されます。
+ レプリケート元バケットのオブジェクトが暗号化されていない場合、レプリケート先バケットのレプリカオブジェクトはレプリケート先バケットのデフォルトの暗号化設定を使用して暗号化されます。そのため、レプリケート元のオブジェクトのエンティティタグ (ETag) はレプリカオブジェクトの ETag とは異なります。アプリケーションで ETag を使用している場合は、アプリケーションを更新して、この違いを反映する必要があります。
+ レプリケート元バケット内のオブジェクトが Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、または AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) を使用して暗号化されている場合、レプリケート先バケットのレプリカオブジェクトは、レプリケート元オブジェクトと同じタイプの暗号化を使用します。レプリケート先バケットのデフォルトの暗号化設定は使用されません。
SSE-KMS を使用したデフォルト暗号化の使用については、「[暗号化オブジェクトのレプリケート](replication-config-for-kms-objects.md)」を参照してください。
## デフォルトの暗号化で Amazon S3 バケットキーを使用する
新しいオブジェクトで SSE-KMS をデフォルトの暗号化として使用するようにバケットを設定する場合は、S3 バケットキーを設定することもできます。S3 バケットキーは、Amazon S3 から AWS KMS へのトランザクションの数を減らし、SSE-KMS のコストを削減します。
新しいオブジェクトで SSE-KMS の S3 バケットキーを使用するようにバケットを設定すると、AWS KMS によりバケットレベルのキーが生成されます。このキーは、バケット内のオブジェクトの一意の[データキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)を作成するために使用されます。この S3 バケットキーは Amazon S3 内で期間限定で使用されるため、Amazon S3 で AWS KMS にリクエストを実行し、暗号化オペレーションを完了する必要性が軽減されます。
S3 バケットキーの使用の詳細については、「[Amazon S3 バケットキーの使用](bucket-key.md)」を参照してください。
# デフォルトの暗号化の設定
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルト暗号化に関するよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
Amazon S3 バケットにはデフォルトで暗号化が有効化されており、新しいオブジェクトは Amazon S3 マネージドキー (SSE-S3) を使用してサーバー側の暗号化により自動的に暗号化されます。この暗号化は Amazon S3 バケット内のすべての新しいオブジェクトに適用され、費用はかかりません。
キーローテーションやアクセスポリシーの付与の管理など、暗号化キーをより細かく制御する必要がある場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、または AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) を使用できます。SSE-KMS に関する詳細は、「[AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定](specifying-kms-encryption.md)」を参照してください。DSSE-KMS に関する詳細については、「[AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の使用](UsingDSSEncryption.md)」を参照してください。
別のアカウントが所有している KMS キーを使用する場合は、そのキーを使用するアクセス許可が必要です。KMS キーのクロスアカウント権限の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[他のアカウントで使用できる KMS キーを作成する](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)」を参照してください。
デフォルトのバケット暗号化を SSE-KMS に設定すると、S3 バケットキーも設定して、AWS KMS リクエストのコストを削減することができます。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
**注記**
[PutBucketEncryption](https://docs.aws.amazon.com//AmazonS3/latest/API/API_PutBucketEncryption.html) を使用してデフォルトのバケット暗号化を SSE-KMS に設定する場合、KMS キー ID が正しいことを確認する必要があります。Amazon S3 は PutBucketEncryption リクエストで提供された KMS キー ID を検証しません。
S3 バケットのデフォルトの暗号化の使用に追加料金はかかりません。デフォルトの暗号化動作を設定するためのリクエストには、標準 Amazon S3 リクエスト料金がかかります。料金については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)」を参照してください。SSE-KMS および DSSE-KMS の場合、AWS KMS の料金が適用され、これらは「[AWS KMS の料金](https://aws.amazon.com/kms/pricing/)」に記載されています。
お客様が用意した暗号化キーを使用したサーバー側の暗号化 (SSE-C) はサポートされていません。
Amazon S3 コンソール、AWS SDK、Amazon S3 REST API、および AWS Command Line Interface (AWS CLI) を使用して、Amazon S3 で S3 バケットのデフォルトの暗号化を設定できます。
**デフォルトの暗号化を有効にする前に注意する変更**
バケットに対してデフォルトの暗号化を有効にした後は、以下の暗号化動作が適用されます。
+ デフォルト暗号化が有効にされる前にバケットに存在していたオブジェクトの暗号化は、変更されません。
+ デフォルト暗号化を有効にした後、オブジェクトをアップロードするとします。
+ `PUT` リクエストヘッダーに暗号化情報が含まれていない場合、Amazon S3 はオブジェクトを暗号化するために、バケットのデフォルトの暗号化設定を使用します。
+ `PUT` リクエストヘッダーに暗号化情報が含まれている場合、Amazon S3 は `PUT` リクエストの暗号化情報を使用して、オブジェクトを Amazon S3 に保存する前に暗号化します。
+ デフォルト暗号化設定として SSE-KMS または DSSE-KMS オプションを使用する場合、AWS KMS の 1 秒あたりのリクエスト数 (RPS) 制限が適用されます。AWS KMS クォータの詳細およびクォータの引き上げをリクエストする方法については、**「AWS Key Management Service デベロッパーガイド」の「[クォータ](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)」を参照してください。
**注記**
デフォルトの暗号化が有効になる前にアップロードされたオブジェクトは、暗号化されません。既存のオブジェクトの暗号化の詳細については、「[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)」を参照してください。
## S3 コンソールの使用
**Amazon S3 バケットにデフォルトの暗号化を設定するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **[バケット]** リストで、目的のバケットの名前を選択します。
1. **[プロパティ]** タブを選択します。
1. **[デフォルトの暗号化]** で、**[編集]** を選択します。
1. 暗号化を設定するには、**[暗号化タイプ]** で次のいずれかを選択します。
+ **Amazon S3 マネージドキーを用いたサーバー側の暗号化 (SSE-S3)**
+ **AWS Key Management Service キーによるサーバー側の暗号化 (SSE-KMS)**
+ **AWS Key Management Service キーによる二層式サーバー側の暗号化 (DSSE-KMS)**
**重要**
デフォルトの暗号化設定として SSE-KMS または DSSE-KMS オプションを使用する場合、AWS KMS の 1 秒あたりのリクエスト数 (RPS) 制限が適用されます。AWS KMS クォータの詳細およびクォータの引き上げをリクエストする方法については、**「AWS Key Management Service デベロッパーガイド」の「[クォータ](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)」を参照してください。
バケットに別のタイプのデフォルト暗号化を指定しない限り、バケットと新しいオブジェクトはデフォルトで SSE-S3 で暗号化されます。デフォルトの暗号化の詳細については、「[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)」を参照してください。
Amazon S3 のサーバー側の暗号化を使用してデータを暗号化する方法の詳細については、「[Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)](UsingServerSideEncryption.md)」を参照してください。
1. **AWS Key Management Service キーによるサーバー側の暗号化 (SSE-KMS)** または **AWS Key Management Service キーによる二層式サーバー側の暗号化 (DSSE-KMS)** を選択した場合は、次の操作を行います。
1. **[AWS KMS キー]** で、次のいずれかの方法で KMS キーを指定します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS キー**を選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
**重要**
バケットと同じ AWS リージョン で有効になっている KMS キーのみを使用できます。[**Choose from your KMS keys**] (KMS キーから選択する) を選択する場合、S3 コンソールにはリージョンごとに 100 個の KMS キーしか表示されません。同じリージョンに 100 個以上の KMS キーがある場合、S3 コンソールには最初の 100 個の KMS キーしか表示されません。コンソールに表示されていない KMS キーを使用するには、**[AWS KMS key ARN を入力]** を選択し、KMS キー ARN を入力します。
Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 は、対称暗号化 KMS キーのみをサポートします。これらのキーの詳細については、「**AWS Key Management Service デベロッパーガイド」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
Amazon S3 における SSE-KMS の使用の詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。DSSE-KMS の使用の詳細については、「[AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の使用](UsingDSSEncryption.md)」を参照してください。
1. SSE-KMS でデフォルトの暗号化を使用するようにバケットを設定する場合は、S3 バケットキーを有効にすることもできます。S3 バケットキーは、Amazon S3 から AWS KMS へのリクエストトラフィックを減らし、暗号化のコストを削減します。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
S3 バケットキーを使用するには、**[バケットキー]** で **[有効化]** を選択します。
**注記**
S3 バケットキーは DSSE-KMS ではサポートされていません。
1. **[Save changes]** (変更の保存) をクリックします。
## の使用AWS CLI
以下の例では、SSE-S3 を使用するか、SSE-KMS と S3 バケット キーを使用して、デフォルトの暗号化を設定する方法を示します。
デフォルトの暗号化の詳細については、[[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)] を参照してください。AWS CLI を使用してデフォルトの暗号化を設定する方法の詳細については、[put-bucket-encryption](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-encryption.html) を参照してください。
**Example - SSE-S3 を使用したデフォルトの暗号化**
この例では、Amazon S3 マネージドキーを使用したデフォルトのバケット暗号化を設定します。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
}
}
]
}'
```
**Example - S3 バケットキーを使用した SSE-KMS でのデフォルトの暗号化**
この例では、S3 バケットキーを使用して SSE-KMS でデフォルトのバケット暗号化を設定します。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "aws:kms",
"KMSMasterKeyID": "KMS-Key-ARN"
},
"BucketKeyEnabled": true
}
]
}'
```
## REST API の使用
REST API `PutBucketEncryption` オペレーションを使用して、デフォルト暗号化を有効にし、使用するサーバー側の暗号化のタイプ (SSE-S3、SSE-KMS、または DSSE-KMS) を設定します。
詳細については、「**Amazon Simple Storage Service API リファレンス」の「[https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html)」を参照してください。
# AWS CloudTrail および Amazon EventBridge によるデフォルト暗号化のモニタリング
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルト暗号化に関するよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
AWS CloudTrail イベントを使用して、Amazon S3 バケットのデフォルトの暗号化設定リクエストを追跡できます。CloudTrail ログでは、以下の API イベント名が使用されます。
+ `PutBucketEncryption`
+ `GetBucketEncryption`
+ `DeleteBucketEncryption`
これらの API コールの CloudTrail イベントと一致するように EventBridge ルールを作成することもできます。CloudTrail イベントの詳細については、[[コンソールを使用してバケット内のオブジェクトのログ記録を有効にする](enable-cloudtrail-logging-for-s3.md#enable-cloudtrail-events)] を参照してください。EventBridge イベントの詳細については、「[AWS のサービス からのイベント](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-service-event.html)」を参照してください。
オブジェクトレベルの Amazon S3 アクションに CloudTrail ログを使用して、Amazon S3 への `PUT` および `POST` リクエストを追跡できます。これらのアクションを使用すると、受信 `PUT` リクエストに暗号化ヘッダーがない場合に、デフォルトの暗号化を使用してオブジェクトが暗号化されているかどうかを確認できます。
デフォルトの暗号化設定を使用して Amazon S3 がオブジェクトを暗号化すると、ログには名前と値のペアとして、`"SSEApplied":"Default_SSE_S3"`、`"SSEApplied":"Default_SSE_KMS"`、または `"SSEApplied":"Default_DSSE_KMS"` フィールドの 1 つが含まれます。
`PUT` の暗号化ヘッダーを使用して Amazon S3 がオブジェクトを暗号化すると、ログには名前と値のペアとして、`"SSEApplied":"SSE_S3"`、`"SSEApplied":"SSE_KMS"`、`"SSEApplied":"DSSE_KMS"`、または `"SSEApplied":"SSE_C"` フィールドの 1 つが含まれます。
マルチパートアップロードについては、この情報は `InitiateMultipartUpload` API リクエストに含まれています。CloudTrail と CloudWatch の併用の詳細については、「[Amazon S3 でのログ記録とモニタリング](monitoring-overview.md)」を参照してください。
# デフォルトの暗号化のよくある質問
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。256 ビットの高度暗号化規格 (AES-256) を使用する SSE-S3 は、すべての新しいバケットと、デフォルトの暗号化がまだ設定されていない既存の S3 バケットに自動的に適用されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、AWS CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS Command Line Interface (AWS CLI) と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。
以下のセクションでは、この更新に関する質問に答えます。
**Amazon S3 は、既にデフォルトの暗号化が設定されている既存のバケットのデフォルトの暗号化設定を変更しますか?**
いいえ。SSE-S3 または AWS Key Management Service (AWS KMS) キーを使用したサーバー側の暗号化 (SSE-KMS) が設定されている既存のバケットのデフォルトの暗号化設定は変更されません。バケットのデフォルトの暗号化動作を設定する方法の詳細については、「[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)」を参照してください。SSE-S3 および SSE-KMS 暗号化設定に関する詳細は、「[サーバー側の暗号化によるデータの保護](serv-side-encryption.md)」を参照してください。
**デフォルトの暗号化が設定されていない既存のバケットでもデフォルトの暗号化は有効になりますか?**
はい。Amazon S3 は、暗号化されていない既存のバケットすべてにデフォルトの暗号化を設定して、これらのバケットにアップロードされる新しいオブジェクトの暗号化の基本レベルとして、S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) を適用するようになりました。既存の暗号化されていないバケットに既に存在するオブジェクトは、自動的に暗号化されません。
**新しいオブジェクトアップロードのデフォルトの暗号化ステータスを表示する方法を教えてください。**
現在、AWS CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS Command Line Interface (AWS CLI) と AWS SDK の追加の Amazon S3 API レスポンスヘッダーで、新しいオブジェクトのアップロードのデフォルトの暗号化ステータスを確認できます。
+ CloudTrail イベントを確認するには、「*AWS CloudTrail ユーザーガイド*」の「[CloudTrail コンソールで CloudTrail イベントを表示する](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events-console.html)」を参照してください。CloudTrail ログは、Amazon S3 への `PUT` および `POST` リクエストの API トラッキングを提供します。バケット内のオブジェクトを暗号化するためにデフォルトの暗号化が使用されている場合、`PUT` および `POST` API リクエストの CloudTrail ログには、名前と値のペアとして次のフィールドが含まれます。`"SSEApplied":"Default_SSE_S3"`
+ S3 インベントリにおける新しいオブジェクトのアップロードの自動暗号化ステータスを確認するには、**[Encryption]** (暗号化) メタデータフィールドを含むように S3 インベントリレポートを設定し、レポート内の新しいオブジェクトごとに暗号化ステータスを確認します。詳細については、「[Amazon S3 インベントリの設定](https://docs.aws.amazon.com/AmazonS3/latest/userguide/configure-inventory.html#storage-inventory-setting-up)」を参照してください。
+ S3 ストレージレンズにおける新しいオブジェクトのアップロードの自動暗号化ステータスを確認するには、S3 ストレージレンズダッシュボードを設定し、ダッシュボードの **[Data protection]** (データ保護) カテゴリで、**[Encrypted bytes]** (暗号化されたバイト数) メトリクスと **[Encrypted object count]** (暗号化されたオブジェクト数) メトリクスを確認します。詳細については、「[S3 コンソールの使用](storage_lens_creating_dashboard.md#storage_lens_console_creating)」および「[ダッシュボードで S3 Storage Lens のメトリクスを表示する](storage_lens_view_metrics_dashboard.md)」を参照してください。
+ Amazon S3 コンソールでバケットレベルの自動暗号化ステータスを確認するには、Amazon S3 コンソールで Amazon S3 バケットの**デフォルトの暗号化**を確認します。詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
+ 自動暗号化ステータスを AWS Command Line Interface (AWS CLI) および AWS SDK の追加の Amazon S3 API レスポンスヘッダー `x-amz-server-side-encryption` として表示するには、[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) や [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) などのオブジェクトアクション API を使用するときにレスポンス ヘッダーを確認してください。
**この変更を利用するには何をすればよいですか?**
既存のアプリケーションに変更を加える必要はありません。すべてのバケットでデフォルトの暗号化が有効になっているため、Amazon S3 にアップロードされたすべての新しいオブジェクトは自動的に暗号化されます。
**バケットに書き込まれる新しいオブジェクトの暗号化を無効にすることはできますか?**
いいえ。SSE-S3 は、バケットにアップロードされるすべての新しいオブジェクトに適用される新しい基本レベルの暗号化です。新しいオブジェクトアップロードの暗号化を無効にすることはできなくなりました。
**私の請求は影響を受けますか?**
いいえ。SSE-S3 を使用したデフォルトの暗号化は、追加料金なしで利用できます。通常どおり、ストレージ、リクエスト、その他の S3 機能の料金が請求されます。料金については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)」を参照してください。
**Amazon S3 は、暗号化されていない既存のオブジェクトを暗号化しますか?**
いいえ。 2023 年 1 月 5 日以降、Amazon S3 は新しいオブジェクトのアップロードのみを自動的に暗号化します。既存のオブジェクトを暗号化するには、S3 Batch オペレーションを使用してオブジェクトの暗号化されたコピーを作成します。これらの暗号化されたコピーには、既存のオブジェクトデータと名前が保持され、指定した暗号化キーを使用して暗号化されます。詳細については、「*AWS ストレージブログ*」の「[Amazon S3 バッチオペレーションによるオブジェクトの暗号化](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)」を参照してください。
**このリリース以前は、バケットの暗号化を有効にしていませんでした。オブジェクトへのアクセス方法を変更する必要がありますか。**
いいえ。SSE-S3 を使用したデフォルトの暗号化は、Amazon S3 に書き込まれるときにデータを自動的に暗号化し、お客様がデータにアクセスするときに復号します。自動的に暗号化されたオブジェクトへのアクセス方法に変更はありません。
**クライアント側の暗号化オブジェクトにアクセスする方法を変更する必要がありますか。**
いいえ。Amazon S3 にアップロードされる前に暗号化されたクライアント側の暗号化されたオブジェクトはすべて、暗号化された暗号文オブジェクトとして Amazon S3 に送られます。これらのオブジェクトには SSE-S3 暗号化レイヤーが追加されます。クライアント側の暗号化オブジェクトを使用するワークロードでは、クライアントサービスや認可設定を変更する必要はありません。
**注記**
更新されたバージョンの AWS プロバイダーを使用していない HashiCorp Terraform ユーザーは、お客様定義の暗号化設定なしで新しい S3 バケットを作成した後、予期しないドリフトが発生する可能性があります。このドリフトを避けるには、お使いの Terraform AWS プロバーダーバージョンを次のいずれかのバージョンに更新してください。4.x のいずれかのリリース、3.76.1、2.70.4。
# 既存データのサーバー側の暗号化の更新
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、オブジェクトは Amazon S3 マネージドキー (SSE-S3) を使用してサーバー側の暗号化により自動的に暗号化されます。このデフォルトの暗号化設定は Amazon S3 バケット内のすべての新しいオブジェクトに適用されます。
`UpdateObjectEncryption` API オペレーションを使用すると、汎用バケット内の既存の暗号化されたオブジェクトのサーバー側の暗号化タイプを、Amazon S3 マネージド暗号化 (SSE-S3) によるサーバー側の暗号化から AWS Key Management Service (AWS KMS) 暗号化キーによるサーバー側の暗号化 (SSE-KMS) にアトミックに更新できます。`UpdateObjectEncryption` API オペレーションでは、[エンベロープ暗号化](https://docs.aws.amazon.com/kms/latest/developerguide/kms-cryptography.html#enveloping)を使用して、新しく指定したサーバー側の暗号化タイプでオブジェクトの暗号化と復号に使用されたデータキーを再暗号化します。
Amazon S3 は、データ移動なしでこの暗号化タイプの更新を実行します。つまり、`UpdateObjectEncryption` オペレーションを使用すると、データはコピーされず、S3 Glacier Flexible Retrieval または S3 Glacier Deep Archive にアーカイブされたオブジェクトは復元されず、S3 Intelligent-Tiering ストレージクラスのオブジェクトは階層間で移動されません。さらに、`UpdateObjectEncryption` オペレーションでは、ストレージクラス、作成日、最終更新日、ETag、チェックサムプロパティなど、すべてのオブジェクトメタデータプロパティを保持します。
`UpdateObjectEncryption` オペレーションは、汎用バケットでサポートされているすべての S3 ストレージクラスでサポートされています。`UpdateObjectEncryption` オペレーションを使用して、次の操作を実行できます。
+ 暗号化されたオブジェクトを Amazon S3 マネージド暗号化 (SSE-S3) によるサーバー側の暗号化から AWS Key Management Service (AWS KMS) 暗号化キーによるサーバー側の暗号化 (SSE-KMS) に変更します。
+ オブジェクトレベルの SSE-KMS 暗号化オブジェクトを更新して S3 バケットキーを使用するようにすると、Amazon S3 から AWS KMS への AWS KMS リクエストトラフィックが減少します。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
+ カスタムキーローテーション標準に準拠できるように、データの暗号化に使用されるカスタマーマネージド KMS キーを変更します。
**注記**
暗号化されていないソースオブジェクトや、AWS KMS keys による二層式サーバー側の暗号化 (DSSE-KMS)、またはお客様が用意した暗号化キー (SSE-C) のいずれかで暗号化されたソースオブジェクトは、このオペレーションではサポートされていません。
通常、`UpdateObjectEncryption` オペレーションは、S3 Glacier Flexible Retrieval や S3 Glacier Deep Archive などのオブジェクトのサイズやストレージクラスに関係なく、ミリ秒単位で完了します。このオペレーションは S3 Intelligent-Tiering のアクセスとしてカウントされないため、オブジェクトのサーバー側の暗号化タイプを変更しても、低頻度アクセス階層またはアーカイブインスタントアクセス階層のオブジェクトは高頻度アクセス階層に自動的に戻されません。
`UpdateObjectEncryption` は、Amazon S3 サーバーアクセスログと AWS CloudTrail データイベントに記録されるオブジェクトレベル (データプレーン) API オペレーションです。詳細については、「[Amazon S3 のログ記録オプション](logging-with-S3.md)」を参照してください。
`UpdateObjectEncryption` オペレーションの料金は、`PUT`、`COPY`、`POST`、`LIST` リクエスト (1,000 リクエストあたり) と同じで、基になるオブジェクトのストレージクラスに関係なく、常に S3 Standard ストレージクラスリクエストとして課金されます。詳細については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)」を参照してください。
## 制限と考慮事項
`UpdateObjectEncryption` オペレーションを使用する場合、以下の制限と考慮事項が適用されます。
+ `UpdateObjectEncryption` オペレーションでは、暗号化されていないオブジェクトや、AWS KMS keys による二層式サーバー側の暗号化 (DSSE-KMS) またはお客様が用意した暗号化キー (SSE-C) のいずれかで暗号化されたオブジェクトはサポートされません。さらに、リクエストされた新しい暗号化タイプの `UpdateObjectEncryption` リクエストとして SSE-S3 を指定することはできません。
+ `UpdateObjectEncryption` オペレーションを使用して、S3 バージョニングが有効になっているバケット内のオブジェクトを更新できます。特定のバージョンの暗号化タイプを更新するには、`UpdateObjectEncryption` リクエストでバージョン ID を指定する必要があります。バージョン ID を指定しない場合、`UpdateObjectEncryption` リクエストはオブジェクトの現在のバージョンに対して実行されます。S3 バージョニングの詳細については、[S3 バージョニングによる複数のバージョンのオブジェクトの保持](Versioning.md) を参照してください。
+ `UpdateObjectEncryption` オペレーションは、S3 Object Lock の保持モードまたはリーガルホールドが適用されているオブジェクトで失敗します。オブジェクトにガバナンスモードの保持期間またはリーガルホールドがある場合は、`UpdateObjectEncryption` リクエストを発行する前に、まずオブジェクトの Object Lock ステータスを削除する必要があります。Object Lock コンプライアンスモードの保持期間が適用されているオブジェクトでは、`UpdateObjectEncryption` オペレーションを使用できません。S3 オブジェクトロックの詳細については、「[S3 Object Lock を使用したオブジェクトのロック](object-lock.md)」を参照してください。
+ ライブレプリケーションが有効になっているソースバケットに対する `UpdateObjectEncryption` リクエストでは、レプリケート先バケットでレプリカイベントが開始されません。ソースバケットとレプリケート先バケットの両方のオブジェクトの暗号化タイプを変更する場合は、ソースバケットとレプリケート先バケットのオブジェクトに対して個別の `UpdateObjectEncryption` リクエストを開始する必要があります。
+ デフォルトでは、カスタマー管理の KMS キーを指定するすべての `UpdateObjectEncryption` リクエストは、バケット所有者の AWS アカウントが所有する KMS キーに制限されます。AWS Organizations を使用している場合は、AWS サポート に連絡して、組織内の他のメンバーアカウントが所有する AWS KMS keys を使用する機能をリクエストできます。
+ S3 バッチレプリケーションを使用してデータセットをリージョン間でレプリケートし、オブジェクトのサーバー側の暗号化タイプを SSE-S3 から SSE-KMS に更新したことがある場合は、追加のアクセス許可が必要になる場合があります。ソースリージョンバケットでは、`kms:decrypt` アクセス許可が必要です。次に、レプリケート先リージョンのバケットの `kms:decrypt` および `kms:encrypt` アクセス許可が必要です。
+ `UpdateObjectEncryption` リクエストで完全な KMS キー ARN を指定する必要があります。エイリアス名またはエイリアス ARN を使用することはできません。完全な KMS キー ARN は、AWS KMS コンソールまたは AWS KMS `DescribeKey` API を使用して判断できます。
## 必要なアクセス許可
`UpdateObjectEncryption` オペレーションを実行するには、次のアクセス許可が必要です。
+ `s3:PutObject`
+ `s3:UpdateObjectEncryption`
+ `kms:Encrypt`
+ `kms:Decrypt`
+ `kms:GenerateDataKey`
+ `kms:ReEncrypt*`
AWS Organizations を使用している場合は、組織内の他の AWS アカウントのカスタマーマネージド KMS キーでこのオペレーションを使用するには、`organizations:DescribeAccount` アクセス許可が必要です。また、AWS サポート に連絡して、組織内の他のメンバーアカウントが所有する AWS KMS keys を使用する機能をリクエストする必要があります。
`UpdateObjectEncryption` オペレーションを実行するには、IAM ロールに次の AWS Identity and Access Management (IAM) ポリシーを追加します。このポリシーを使用するには、`amzn-s3-demo-bucket` を汎用バケットの名前に置き換え、もう一方の `user input placeholders` を独自の情報に置き換えます。
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowUpdateObjectEncryption",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:UpdateObjectEncryption",
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:ReEncrypt*",
"organizations:DescribeAccount"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
## 暗号化を一括更新する
1 回のリクエストで複数の Amazon S3 オブジェクトのサーバー側の暗号化タイプを更新するには、S3 バッチオペレーションを使用できます。S3 バッチオペレーションに操作対象のオブジェクトのリストを提供するか、プレフィックス、ストレージクラス、作成日、暗号化タイプ、KMS キー ARN、S3 バケットキーのステータスなどのオブジェクトメタデータに基づいてオブジェクトリストを生成するようにバッチオペレーションに指示することもできます。S3 バッチオペレーションは、各 API オペレーションを呼び出して、指定されたオペレーションを実行します。1 つのバッチオペレーションジョブで、ペタバイト単位のデータを含むバケット内の数十億のオブジェクトに対して、指定されたオペレーションを実行できます。バッチオペレーションの詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」を参照してください。
S3 バッチオペレーション機能は、進捗状況の追跡、通知の送信、すべてのアクションの詳細な完了レポートの保存を行い、フルマネージドの監査可能なサーバーレスエクスペリエンスを提供します。S3 バッチオペレーションは、Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、AWS SDK、または Amazon S3 REST API を通じて使用できます。詳細については、「[オブジェクトの暗号化を更新する](batch-ops-update-encryption.md)」を参照してください。
## オブジェクトの暗号化の更新
オブジェクトのサーバー側の暗号化タイプは、AWS Command Line Interface (AWS CLI) AWS SDK または Amazon S3 REST API を使用して更新できます。
### オブジェクトの暗号化を更新する
#### の使用AWS CLI
次のコマンドを実行するには、AWS CLI をインストールして設定する必要があります。AWS CLI をまだインストールしていない場合は、「*AWS Command Line Interface ユーザーガイド*」の「[AWS CLI の最新バージョンのインストールまたは更新](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html)」を参照してください。
別の方法として、AWS CloudShell を使用してコンソールから AWS CLI コマンドを実行することもできます。AWS CloudShell は、AWS マネジメントコンソールから直接起動できる、ブラウザベースの事前認証済みシェルです。詳細については、「AWS CloudShell ユーザーガイド」の「[CloudShell とは](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html)」と「[AWS CloudShell の使用開始](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html)」を参照してください。**
**AWS CLI を使用してオブジェクトの暗号化を更新するには**
次のコマンド例を使用するには、`user input placeholders` をユーザー自身の情報に置き換えます。
1. 次のコマンドを使用して、汎用バケット (`amzn-s3-demo-bucket` など) 内の 1 つのオブジェクト (`index.html`) の暗号化を更新し、S3 バケットキーで SSE-KMS を使用します。
```
aws s3api update-object-encryption \
--bucket amzn-s3-demo-bucket \
--key index.html \
--object-encryption '{"SSEKMS": { "KMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/f12a345a-678e-9bbb-1025-62e317037583", "BucketKeyEnabled": true }}'
```
**注記**
完全な AWS KMS key Amazon リソースネーム (ARN) を指定する必要があります。KMS キー ID と KMS キーエイリアスはサポートされていません。
1. `head-object` コマンドを実行して、オブジェクトの更新された暗号化タイプを表示します。
```
aws s3api head-object --bucket amzn-s3-demo-bucket --key index.html
```
#### REST API の使用
オブジェクトの暗号化を更新するには、REST リクエストを送信できます。詳細については、[ を参照してください。UpdateObjectEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateObjectEncryption.html)
#### AWS SDK の使用
AWS SDK を使用して、オブジェクトの暗号化を更新できます。詳細については、「[サポートされる SDK のリスト](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateObjectEncryption.html#API_UpdateObjectEncryption_SeeAlso)」を参照してください。
------
#### [ Java ]
**Example**
次の AWS SDK for Java 2.x の例では、汎用バケット内のオブジェクトの暗号化タイプを SSE-KMS に更新します。
```
public void updateObjectEncryption(String bucketName,
String objectKey,
String versionId,
String kmsKeyArn,
boolean bucketKeyEnabled) {
// Create the target object encryption type.
ObjectEncryption objectEncryption = ObjectEncryption.builder()
.ssekms(SSEKMSEncryption.builder()
.kmsKeyArn(kmsKeyArn)
.bucketKeyEnabled(bucketKeyEnabled)
.build())
.build();
// Create the UpdateObjectEncryption request.
UpdateObjectEncryptionRequest request = UpdateObjectEncryptionRequest.builder()
.bucket(bucketName)
.key(objectKey)
.versionId(versionId)
.objectEncryption(objectEncryption)
.build();
// Update the object encryption.
try {
getS3Client().updateObjectEncryption(request);
logger.info("Object encryption updated to SSE-KMS for {} in bucket {}", objectKey, bucketName);
} catch (S3Exception e) {
logger.error("Failed to update to object encryption: {} - Error code: {}", e.awsErrorDetails().errorMessage(),
e.awsErrorDetails().errorCode());
throw e;
}
}
```
------
#### [ Python ]
**Example**
次の AWS SDK for Python (Boto3) の例は、汎用バケット内のオブジェクトの暗号化タイプを SSE-KMS に更新する方法を示しています。
```
response = client.update_object_encryption(
Bucket='string',
Key='string',
VersionId='string',
ObjectEncryption={
'SSEKMS': {
'KMSKeyArn': 'string',
'BucketKeyEnabled': True|False
}
}
)
```
------
# Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルト暗号化に関するよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
Amazon S3 バケットへの新しいオブジェクトのアップロードはすべて、デフォルトでは Amazon S3 マネージドキーによる暗号化 (SSE-S3) で暗号化されます。
サーバー側の暗号化は、保管中のデータを保護します。Amazon S3 は、一意のキーで各オブジェクトを暗号化します。追加の保護措置として、S3 は定期的にローテーションされるキーを使ってキーそのものを暗号化します。Amazon S3 サーバー側の暗号化では、256 ビットの高度暗号化標準 Galois/Counter Mode (AES-GCM) を使用して、アップロードされたすべてのオブジェクトを暗号化します。
Amazon S3 が管理するキーによるサーバー側の暗号化 (SSE−S3) を使用するために、追加でかかる料金はありません。ただし、デフォルトの暗号化機能を設定するためのリクエストには、標準 Amazon S3 リクエスト料金がかかります。料金については、[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)を参照してください。
Amazon S3 マネージドキーのみを使用してデータアップロードを暗号化する必要がある場合は、次のバケットポリシーを使用できます。例えば、次のバケットポリシーは、サーバー側の暗号化を要求する `x-amz-server-side-encryption` ヘッダーがリクエストに含まれない限り、オブジェクトをアップロードする許可を拒否します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "DenyObjectsThatAreNotSSES3",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "AES256"
}
}
}
]
}
```
------
**注記**
サーバー側の暗号化では、オブジェクトのメタデータではなく、オブジェクトデータのみが暗号化されます。
## サーバー側の暗号化での API サポート
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 `PUT` リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を更新できます。
`PUT` リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。
汎用バケットのデフォルトの暗号化設定を変更する方法の詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
バケットのデフォルトの暗号化設定を SSE-KMS に変更しても、バケット内の既存の Amazon S3 オブジェクトの暗号化タイプは変更されません。デフォルトの暗号化設定を SSE-KMS に更新した後に既存のオブジェクトの暗号化タイプを変更するには、Amazon S3 バッチオペレーションを使用できます。S3 バッチオペレーションにオブジェクトのリストを指定すると、バッチオペレーションが対応する API オペレーションを呼び出します。[オブジェクトのコピー](batch-ops-copy-object.md) アクションを使用して既存のオブジェクトをコピーし、SSE-KMS で暗号化されたオブジェクトと同じバケットに書き戻すことができます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」および *AWS Storage Blog* の投稿「[How to retroactively encrypt existing objects in Amazon S3 using S3 Inventory, Amazon Athena, and S3 Batch Operations](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)」を参照してください。
オブジェクト作成の REST API を使用してサーバー側の暗号化を設定するには、`x-amz-server-side-encryption` リクエストヘッダーを提供します。REST API の詳細については、[REST API の使用](specifying-s3-encryption.md#SSEUsingRESTAPI) を参照してください。
以下の Amazon S3 API でこのヘッダーがサポートされています。
+ **PUT オペレーション** − `PUT` API を使用してデータをアップロードする場合は、リクエストヘッダーを指定します。詳細については、「[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)」を参照してください。
+ **マルチパートアップロードの開始** — マルチパートアップロード API オペレーションを使用して大きいオブジェクトをアップロードするときに、開始リクエストでヘッダーを指定します。詳細については、[Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html) を参照してください。
+ **COPY オペレーション** – オブジェクトをコピーする場合、ソースオブジェクトとターゲットオブジェクトがあります。詳細については、[PUT Object − Copy](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html) を参照してください。
**注記**
`POST` オペレーションを使用してオブジェクトをアップロードする場合は、リクエストヘッダーを指定する代わりに、フォームフィールドで同じ情報を指定します。詳細については、[POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) を参照してください。
AWS SDK にも、サーバー側の暗号化を要求するために使用できるラッパー API があります。また、AWS マネジメントコンソール を使用して、オブジェクトをアップロードしてサーバー側の暗号化を要求することもできます。
詳細については、*AWS Key Management Service デベロッパーガイド*の「[AWS KMS の概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html)」を参照してください。
**Topics**
+ [
## サーバー側の暗号化での API サポート
](#APISupportforServer-SideEncryption)
+ [
# Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) の指定
](specifying-s3-encryption.md)
# Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) の指定
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 `PUT` リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を更新できます。
`PUT` リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。
汎用バケットのデフォルトの暗号化設定を変更する方法の詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
バケットのデフォルトの暗号化設定を SSE-KMS に変更しても、バケット内の既存の Amazon S3 オブジェクトの暗号化タイプは変更されません。デフォルトの暗号化設定を SSE-KMS に更新した後に既存のオブジェクトの暗号化タイプを変更するには、Amazon S3 バッチオペレーションを使用できます。S3 バッチオペレーションにオブジェクトのリストを指定すると、バッチオペレーションが対応する API オペレーションを呼び出します。[オブジェクトのコピー](batch-ops-copy-object.md) アクションを使用して既存のオブジェクトをコピーし、SSE-KMS で暗号化されたオブジェクトと同じバケットに書き戻すことができます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」および *AWS Storage Blog* の投稿「[How to retroactively encrypt existing objects in Amazon S3 using S3 Inventory, Amazon Athena, and S3 Batch Operations](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)」を参照してください。
S3 コンソール、REST API、AWS SDK、および AWS Command Line Interface (AWS CLI) を使用して SSE−S3 を指定できます。詳細については、「[Amazon S3 バケット向けのサーバー側のデフォルトの暗号化動作の設定](bucket-encryption.md)」を参照してください。
## S3 コンソールの使用
このトピックでは、AWS マネジメントコンソール を使用してオブジェクトの暗号化のタイプを設定または変更する方法について説明します。コンソールを使用してオブジェクトをコピーする場合、Amazon S3 はオブジェクトを現状のままコピーします。つまり、ソースが暗号化されている場合、ターゲットオブジェクトも暗号化されます。コンソールを使用して、オブジェクトの暗号化を追加または変更することもできます。
**注記**
オブジェクトが 5 GB 未満の場合は、オブジェクトの暗号化を変更できます。オブジェクトが 5 GB を超える場合は、[AWS CLI](mpu-upload-object.md#UsingCLImpUpload) または [AWS SDK](CopyingObjectsMPUapi.md) を使用してオブジェクトの暗号化を変更する必要があります。
オブジェクトの暗号化の変更に必要な追加のアクセス許可のリストについては、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。このアクセス許可を付与するポリシーの例については、「[Amazon S3 のアイデンティティベースのポリシー例](example-policies-s3.md)」を参照してください。
オブジェクトの暗号化を変更すると、新しいオブジェクトが作成され、古いオブジェクトが置き換えられます。S3 バージョニングが有効になっている場合は、オブジェクトの新しいバージョンが作成され、既存のオブジェクトが古いバージョンになります。また、プロパティを変更するロールは、新しいオブジェクト (またはオブジェクトのバージョン) の所有者になります。
**オブジェクトの暗号化を変更するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. ナビゲーションペインで **[バケット]** を選択してから、**[汎用バケット]** タブをクリックします。変更するオブジェクトを含む Amazon S3 バケットまたはフォルダに移動します。
1. 変更するオブジェクトのチェックボックスをオンにします。
1. **[アクション]** メニューに表示されるオプションのリストから **[サーバー側の暗号化を編集]** を選択します。
1. **[サーバー側の暗号化]** セクションまでスクロールします。
1. **[暗号化設定]** で、**[デフォルトの暗号化にバケット設定を使用する]** または **[デフォルトの暗号化にバケット設定を上書きする]** を選択します。
1. **[デフォルトの暗号化にバケット設定を上書きする]** を選択した場合は、次の暗号化設定を設定します。
1. **[暗号化タイプ]** で、**[Amazon S3 マネージドキーを用いたサーバー側の暗号化 (SSE-S3)]** を選択します。SSE-S3 は、最強のブロック暗号の 1 つである 256 ビットの 高度暗号化規格 (AES-256) を使用して、各オブジェクトを暗号化します。詳細については、「[Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3)](UsingServerSideEncryption.md)」を参照してください。
1. **[追加のコピー設定]** で、**[ソース設定をコピー]** するか、**[設定を指定しない]** か、**[設定を指定]** するかを選択します。**[ソース設定をコピー]** がデフォルトのオプションです。ソース設定の属性なしでオブジェクトのみをコピーする場合は、**[設定を指定しない]** を選択します。ストレージクラス、ACL、オブジェクトタグ、メタデータ、サーバー側の暗号化、その他のチェックサムの設定を指定するには、**[設定を指定]** を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
**注記**
このアクションは、指定されたすべてのオブジェクトに暗号化を適用します。フォルダを暗号化する場合は、保存オペレーションが完了するのを待ってから、フォルダに新しいオブジェクトを追加します。
## REST API の使用
オブジェクト作成時、つまり、新しいオブジェクトをアップロードするときや既存オブジェクトのコピーを作成するときに、リクエストに `x-amz-server-side-encryption` ヘッダーを追加することで、Amazon S3 マネージドキー (SSE-S3) を使用してデータを暗号化するかどうかを指定することができます。ヘッダーの値を、Amazon S3 がサポートする暗号化アルゴリズム `AES256` に設定します。Amazon S3 によりレスポンスヘッダー `x-amz-server-side-encryption` が返されるため、SSE-S3 を使用してオブジェクトが保存されたことを確認できます。
次の REST アップロード API オペレーションは、`x-amz-server-side-encryption` リクエストヘッダーを受け付けます。
+ [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT Object − Copy](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
マルチパートアップロード API オペレーションを使用して大容量のオブジェクトをアップロードするときに、`x-amz-server-side-encryption` ヘッダーを Initiate Multipart Upload リクエストに追加することでサーバー側の暗号化を指定することができます。既存のオブジェクトをコピーする際は、コピー元オブジェクトが暗号化されているかどうかに関係なく、明示的にサーバー側の暗号化を要求しない限り、コピー先オブジェクトは暗号化されません。
次の REST API オペレーションのレスポンスヘッダーは、オブジェクトが SSE-S3 を使用して保存されているときに `x-amz-server-side-encryption` ヘッダーを返します。
+ [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT Object − Copy](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [ パートのアップロード](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [Upload Part − Copy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [ マルチパートアップロードの完了](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Get Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)
+ [Head Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)
**注記**
オブジェクトで SSE−S3 を使用している場合、または、HTTP ステータスコード 400 (BadRequest) エラーが発生する場合、暗号化リクエストヘッダーを `GET` リクエストおよび `HEAD` リクエストに対して送信しないでください。
## AWS SDK の使用
AWS SDK を使用して、Amazon S3 マネージド暗号化キー (SSE-S3) を使用するように Amazon S3 にリクエストできます。このセクションでは、AWS SDK を複数の言語で使用する場合の例を示します。他の SDK については、「[サンプルコードとライブラリ](https://aws.amazon.com/code)」を参照してください。
------
#### [ Java ]
AWS SDK for Java を使用してオブジェクトをアップロードしたら、SSE-S3 を使用してデータを暗号化します。サーバー側の暗号化を要求するには、`ObjectMetadata` の `PutObjectRequest` プロパティを使用して `x-amz-server-side-encryption` リクエストヘッダーを設定します。`putObject()` の `AmazonS3Client` メソッドを呼び出すと、Amazon S3 はデータを暗号化して保存します。
さらに、マルチパートアップロード API オペレーションを使用して、オブジェクトのアップロード時に、SSE-S3 暗号化をリクエストすることもできます。
+ 高レベルマルチパートアップロード API オペレーションを使用するときに、`TransferManager` メソッドを使用して、アップロード時にサーバー側の暗号化をオブジェクトに適用できます。パラメータとして `ObjectMetadata` を受け取る、どのアップロードメソッドを使用してもかまいません。詳細については、「[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md)」を参照してください。
+ 低レベルマルチパートアップロード API オペレーションを使用する場合は、マルチパートアップロードの開始時にサーバー側の暗号化を指定します。`ObjectMetadata` メソッドを呼び出して `InitiateMultipartUploadRequest.setObjectMetadata()` プロパティを追加します。詳細については、[AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level) を参照してください。
オブジェクトの暗号化状態を直接変更することはできません (暗号化されていないオブジェクトの暗号化、または暗号化されたオブジェクトの復号)。オブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピーの目的の暗号化状態を指定してから、元のオブジェクトを削除します。Amazon S3 は、明示的にサーバー側の暗号化を要求した場合にのみ、コピーされたオブジェクトを暗号化します。Java API を通じて、コピーされたオブジェクトの暗号化を要求するには、`ObjectMetadata` プロパティを使用して、`CopyObjectRequest` でサーバー側の暗号化を指定します。
**Example 例**
次の例は、AWS SDK for Java を使用してサーバー側の暗号化を設定する方法を示しています。ここでは、以下のタスクの実行方法について説明します。
+ SSE-S3 を使用して新しいオブジェクトをアップロードします。
+ オブジェクトのコピーを作成して、オブジェクトの暗号化状態を変更する (この例では、以前に暗号化されていないオブジェクトを暗号化する)
+ オブジェクトの暗号化状態を確認する
サーバーサイドの暗号化の詳細については、「[REST API の使用](#SSEUsingRESTAPI)」を参照してください。作業サンプルの作成およびテストの手順については、「AWS SDK for Java のデベロッパーガイド」の「[使用開始](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html)」を参照してください。
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.internal.SSEResultBase;
import com.amazonaws.services.s3.model.*;
import java.io.ByteArrayInputStream;
public class SpecifyServerSideEncryption {
public static void main(String[] args) {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyNameToEncrypt = "*** Key name for an object to upload and encrypt ***";
String keyNameToCopyAndEncrypt = "*** Key name for an unencrypted object to be encrypted by copying ***";
String copiedObjectKeyName = "*** Key name for the encrypted copy of the unencrypted object ***";
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Upload an object and encrypt it with SSE.
uploadObjectWithSSEEncryption(s3Client, bucketName, keyNameToEncrypt);
// Upload a new unencrypted object, then change its encryption state
// to encrypted by making a copy.
changeSSEEncryptionStatusByCopying(s3Client,
bucketName,
keyNameToCopyAndEncrypt,
copiedObjectKeyName);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
private static void uploadObjectWithSSEEncryption(AmazonS3 s3Client, String bucketName, String keyName) {
String objectContent = "Test object encrypted with SSE";
byte[] objectBytes = objectContent.getBytes();
// Specify server-side encryption.
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentLength(objectBytes.length);
objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName,
new ByteArrayInputStream(objectBytes),
objectMetadata);
// Upload the object and check its encryption status.
PutObjectResult putResult = s3Client.putObject(putRequest);
System.out.println("Object \"" + keyName + "\" uploaded with SSE.");
printEncryptionStatus(putResult);
}
private static void changeSSEEncryptionStatusByCopying(AmazonS3 s3Client,
String bucketName,
String sourceKey,
String destKey) {
// Upload a new, unencrypted object.
PutObjectResult putResult = s3Client.putObject(bucketName, sourceKey, "Object example to encrypt by copying");
System.out.println("Unencrypted object \"" + sourceKey + "\" uploaded.");
printEncryptionStatus(putResult);
// Make a copy of the object and use server-side encryption when storing the
// copy.
CopyObjectRequest request = new CopyObjectRequest(bucketName,
sourceKey,
bucketName,
destKey);
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
request.setNewObjectMetadata(objectMetadata);
// Perform the copy operation and display the copy's encryption status.
CopyObjectResult response = s3Client.copyObject(request);
System.out.println("Object \"" + destKey + "\" uploaded with SSE.");
printEncryptionStatus(response);
// Delete the original, unencrypted object, leaving only the encrypted copy in
// Amazon S3.
s3Client.deleteObject(bucketName, sourceKey);
System.out.println("Unencrypted object \"" + sourceKey + "\" deleted.");
}
private static void printEncryptionStatus(SSEResultBase response) {
String encryptionStatus = response.getSSEAlgorithm();
if (encryptionStatus == null) {
encryptionStatus = "Not encrypted with SSE";
}
System.out.println("Object encryption status is: " + encryptionStatus);
}
}
```
------
#### [ .NET ]
オブジェクトをアップロードするときに、それを暗号化するように Amazon S3 に指定できます。既存のオブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピー元オブジェクトを削除します。デフォルトでは、ターゲットオブジェクトのサーバー側の暗号化を明示的に要求した場合、コピーオペレーションではターゲットのみが暗号化されます。`CopyObjectRequest` で SSE-S3 を指定するには、以下を追加します。
```
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
```
オブジェクトのコピー方法を示す作業サンプルについては、[AWS SDK の使用](copy-object.md#CopyingObjectsUsingSDKs) を参照してください。
次の例では、オブジェクトをアップロードします。このリクエストでは、オブジェクトを暗号化するように Amazon S3 に指定します。次に、オブジェクトのメタデータを取得し、使用された暗号化方法を確認します。コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class SpecifyServerSideEncryptionTest
{
private const string bucketName = "*** bucket name ***";
private const string keyName = "*** key name for object created ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 client;
public static void Main()
{
client = new AmazonS3Client(bucketRegion);
WritingAnObjectAsync().Wait();
}
static async Task WritingAnObjectAsync()
{
try
{
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = keyName,
ContentBody = "sample text",
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
};
var putResponse = await client.PutObjectAsync(putRequest);
// Determine the encryption state of an object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = keyName
};
GetObjectMetadataResponse response = await client.GetObjectMetadataAsync(metadataRequest);
ServerSideEncryptionMethod objectEncryption = response.ServerSideEncryptionMethod;
Console.WriteLine("Encryption method used: {0}", objectEncryption.ToString());
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ PHP ]
このトピックでは、バージョン 3 の AWS SDK for PHP のクラスを使用して、Amazon S3 にアップロードするオブジェクトに SSE-S3 を追加する方法を示します。AWS SDK for Ruby API の詳細については、[AWS SDK for Ruby - バージョン 2](https://docs.aws.amazon.com/sdkforruby/api/index.html) を参照してください。
オブジェクトを Amazon S3 にアップロードするには、[Aws\$1S3\$1S3Client::putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) メソッドを使用します。アップロードリクエストに `x-amz-server-side-encryption` リクエストヘッダーを追加するには、`ServerSideEncryption` パラメータを指定して `AES256` 値を設定します。以下に例を示します。サーバー側の暗号化のリクエストについては、[REST API の使用](#SSEUsingRESTAPI) を参照してください。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
// $filepath should be an absolute path to a file on disk.
$filepath = '*** Your File Path ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Upload a file with server-side encryption.
$result = $s3->putObject([
'Bucket' => $bucket,
'Key' => $keyname,
'SourceFile' => $filepath,
'ServerSideEncryption' => 'AES256',
]);
```
レスポンスとして、Amazon S3 は、`x-amz-server-side-encryption` ヘッダーを返します。このヘッダーには、オブジェクトのデータの暗号化に使用された暗号化アルゴリズムの値が設定されています。
マルチパートアップロード API オペレーションを使用して大容量のオブジェクトをアップロードする場合、以下のように、アップロードするオブジェクトに対して SSE-S3 を指定できます。
+ 低レベルのマルチパートアップロード API オペレーションを使用する場合は、[Aws\$1S3\$1S3Client::createMultipartUpload()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) メソッドを呼び出すときにサーバー側の暗号化を指定します。リクエストに `x-amz-server-side-encryption` ヘッダーを追加する場合は、値 `array` を使用して `ServerSideEncryption` パラメータの `AES256` キーを指定します。低レベルのマルチパートアップロード API オペレーションの詳細については、「[AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level)」を参照してください。
+ 高レベルのマルチパートアップロード API オペレーションを使用する場合は、[CreateMultipartUpload](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) API オペレーションの `ServerSideEncryption` パラメータを使用してサーバー側の暗号化を指定します。高レベルのマルチパートアップロード API オペレーションで `setOption()` メソッドを使用する例については、「[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md)」を参照してください。
以下の PHP コード例に示すように、[Aws\$1S3\$1S3Client::headObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#headobject) メソッドを呼び出し、オブジェクトメタデータを取得して、既存のオブジェクトの暗号化状態を確認できます。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Check which server-side encryption algorithm is used.
$result = $s3->headObject([
'Bucket' => $bucket,
'Key' => $keyname,
]);
echo $result['ServerSideEncryption'];
```
[Aws\$1S3\$1S3Client::copyObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#copyobject) メソッドを使用してオブジェクトのコピーを作成し、コピー元のオブジェクトを削除することで、既存のオブジェクトの暗号化状態を変更できます。デフォルトでは、`copyObject()` によってコピー先は暗号化されません。ただし、`ServerSideEncryption` パラメータで `AES256` 値を使用して、コピー先オブジェクトに対するサーバー側の暗号化を明示的にリクエストした場合は除きます。以下の PHP コード例では、オブジェクトのコピーを作成し、コピー先のオブジェクトにサーバー側の暗号化を追加しています。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$sourceBucket = '*** Your Source Bucket Name ***';
$sourceKeyname = '*** Your Source Object Key ***';
$targetBucket = '*** Your Target Bucket Name ***';
$targetKeyname = '*** Your Target Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Copy an object and add server-side encryption.
$s3->copyObject([
'Bucket' => $targetBucket,
'Key' => $targetKeyname,
'CopySource' => "$sourceBucket/$sourceKeyname",
'ServerSideEncryption' => 'AES256',
]);
```
詳細については、以下の各トピックを参照してください。
+ [Amazon S3 向け AWS SDK for PHP Aws\$1S3\$1S3Client クラスの場合](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html)
+ [AWS SDK for PHP ドキュメント](https://aws.amazon.com/documentation/sdk-for-php/)
------
#### [ Ruby ]
AWS SDK for Ruby を使用してオブジェクトをアップロードするときは、SSE-S3 により保管時にオブジェクトを暗号化して保存することを指定できます。オブジェクトは、読み戻すときに自動的に復号されます。
次の AWS SDK for Ruby バージョン 3 のサンプルは、Amazon S3 にアップロードするファイルを保管時に暗号化するよう指定する方法を示しています。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectPutSseWrapper
attr_reader :object
# @param object [Aws::S3::Object] An existing Amazon S3 object.
def initialize(object)
@object = object
end
def put_object_encrypted(object_content, encryption)
@object.put(body: object_content, server_side_encryption: encryption)
true
rescue Aws::Errors::ServiceError => e
puts "Couldn't put your content to #{object.key}. Here's why: #{e.message}"
false
end
end
# Example usage:
def run_demo
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-encrypted-content"
object_content = "This is my super-secret content."
encryption = "AES256"
wrapper = ObjectPutSseWrapper.new(Aws::S3::Object.new(bucket_name, object_content))
return unless wrapper.put_object_encrypted(object_content, encryption)
puts "Put your content into #{bucket_name}:#{object_key} and encrypted it with #{encryption}."
end
run_demo if $PROGRAM_NAME == __FILE__
```
次のコード例は、既存のオブジェクトの暗号化状態を判定する方法を示しています。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectGetEncryptionWrapper
attr_reader :object
# @param object [Aws::S3::Object] An existing Amazon S3 object.
def initialize(object)
@object = object
end
# Gets the object into memory.
#
# @return [Aws::S3::Types::GetObjectOutput, nil] The retrieved object data if successful; otherwise nil.
def object
@object.get
rescue Aws::Errors::ServiceError => e
puts "Couldn't get object #{@object.key}. Here's why: #{e.message}"
end
end
# Example usage:
def run_demo
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-object.txt"
wrapper = ObjectGetEncryptionWrapper.new(Aws::S3::Object.new(bucket_name, object_key))
obj_data = wrapper.get_object
return unless obj_data
encryption = obj_data.server_side_encryption.nil? ? 'no' : obj_data.server_side_encryption
puts "Object #{object_key} uses #{encryption} encryption."
end
run_demo if $PROGRAM_NAME == __FILE__
```
Amazon S3 に保存されたオブジェクトにサーバー側の暗号化が使用されていない場合、メソッドは `null` を返します。
既存のオブジェクトの暗号化状態を変更するには、オブジェクトのコピーを作成し、コピー元オブジェクトを削除します。デフォルトでは、明示的にサーバー側の暗号化を要求しない限り、コピーメソッドはターゲットを暗号化しません。ターゲットオブジェクトの暗号化を要求するには、次の Ruby コードの例に示すように、オプションのハッシュ引数に `server_side_encryption` 値を指定します。このコード例は、オブジェクトをコピーし、コピーを SSE-S3 で暗号化する方法を示しています。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectCopyEncryptWrapper
attr_reader :source_object
# @param source_object [Aws::S3::Object] An existing Amazon S3 object. This is used as the source object for
# copy actions.
def initialize(source_object)
@source_object = source_object
end
# Copy the source object to the specified target bucket, rename it with the target key, and encrypt it.
#
# @param target_bucket [Aws::S3::Bucket] An existing Amazon S3 bucket where the object is copied.
# @param target_object_key [String] The key to give the copy of the object.
# @return [Aws::S3::Object, nil] The copied object when successful; otherwise, nil.
def copy_object(target_bucket, target_object_key, encryption)
@source_object.copy_to(bucket: target_bucket.name, key: target_object_key, server_side_encryption: encryption)
target_bucket.object(target_object_key)
rescue Aws::Errors::ServiceError => e
puts "Couldn't copy #{@source_object.key} to #{target_object_key}. Here's why: #{e.message}"
end
end
# Example usage:
def run_demo
source_bucket_name = "amzn-s3-demo-bucket1"
source_key = "my-source-file.txt"
target_bucket_name = "amzn-s3-demo-bucket2"
target_key = "my-target-file.txt"
target_encryption = "AES256"
source_bucket = Aws::S3::Bucket.new(source_bucket_name)
wrapper = ObjectCopyEncryptWrapper.new(source_bucket.object(source_key))
target_bucket = Aws::S3::Bucket.new(target_bucket_name)
target_object = wrapper.copy_object(target_bucket, target_key, target_encryption)
return unless target_object
puts "Copied #{source_key} from #{source_bucket_name} to #{target_object.bucket_name}:#{target_object.key} and "\
"encrypted the target with #{target_object.server_side_encryption} encryption."
end
run_demo if $PROGRAM_NAME == __FILE__
```
------
## の使用AWS CLI
AWS CLI を使用してオブジェクトをアップロードするときに SSE−S3 を指定するには、次の例を使用します。
```
aws s3api put-object --bucket amzn-s3-demo-bucket1 --key object-key-name --server-side-encryption AES256 --body file path
```
詳細については、*AWS CLI リファレンス*の [put−object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html) を参照してください。AWS CLI を使用してオブジェクトをコピーするときに SSE−S3 を指定するには、[copy−object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html) を参照してください。
## CloudFormation の使用
CloudFormation を使用して暗号化を設定する例については、*AWS CloudFormation ユーザーガイド*の `AWS::S3::Bucket ServerSideEncryptionRule` トピックの「[デフォルト暗号化を備えたバケットの作成](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_with_default_encryption)」および「[AWS KMS サーバー側の暗号化と S3 バケットキーを使用したバケットの作成](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_using_AWS_KMS_server-side_encryption_with_an_S3_Bucket_Key)」の例を参照してください。
# AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用
**重要**
Amazon S3 では、Amazon S3 内のすべてのバケットの基本レベルの暗号化として、Amazon S3 が管理するキー (SSE-S3) によるサーバー側の暗号化が適用されるようになりました。2023 年 1 月 5 日以降、Amazon S3 にアップロードされるすべての新しいオブジェクトは、追加費用なしで、パフォーマンスに影響を与えずに自動的に暗号化されます。S3 バケットのデフォルト暗号化設定と新しいオブジェクトのアップロードのための自動暗号化ステータスは、CloudTrail ログ、S3 インベントリ、S3 ストレージレンズ、Amazon S3 コンソール、および AWS CLI と AWS SDK の追加の Amazon S3 API レスポンスヘッダーとして利用できるようになりました。詳細については、「[デフォルトの暗号化のよくある質問](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)」を参照してください。
サーバー側の暗号化とは、データを受信するアプリケーションまたはサービスによって、送信先でデータを暗号化することです。
Amazon S3 は、新しいオブジェクトをアップロードするときに、Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) を自動的に有効にします。
特に指定しない限り、バケットはデフォルトで SSE-S3 を使用してオブジェクトを暗号化します。ただし、代わりにAWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS) を使用するようにバケットを設定することもできます。詳細については、「[AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定](specifying-kms-encryption.md)」を参照してください。
AWS KMS は、安全で可用性の高いハードウェアおよびソフトウェアを結合するサービスであり、クラウド向けに拡張されたキー管理システムを提供します。Amazon S3 は、AWS KMS (SSE-KMS) によるサーバー側の暗号化を使用して、S3 オブジェクトデータを暗号化します。また、オブジェクトに対して SSE-KMS をリクエストすると、オブジェクトのメタデータの一部としての S3 チェックサムが暗号化された形式で保存されます。チェックサムの詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
KMS キーを使用すると、[AWS マネジメントコンソール](https://console.aws.amazon.com/kms) または [AWS KMS API](https://docs.aws.amazon.com/kms/latest/APIReference/) から AWS KMS を使用して、以下の操作を実行できます。
+ KMS キーの作成、表示、編集、監視、有効化または無効化、更新、削除のスケジュールを一元的に行う。
+ KMS キーの使用方法および使用者を制御するポリシーを定義する。
+ KMS キーの正しい使用状況を監査します。監査は [AWS KMS API](https://docs.aws.amazon.com/kms/latest/APIReference/) ではサポートされていますが、[AWS KMS コンソール](https://console.aws.amazon.com/kms)ではサポートされていません。
AWS KMS のセキュリティ制御は、暗号化関連のコンプライアンス要件を満たすのに役立ちます。これらの KMS キーを使用して、Amazon S3 バケットのデータを保護できます。S3 バケットで SSE−KMS 暗号化を使用する場合、AWS KMS keys はバケットと同じリージョンに存在する必要があります。
AWS KMS keysを使用するための追加料金はかかります。詳細については、*AWS Key Management Service デベロッパーガイド*の [AWS KMS key の概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys)および[AWS KMS の料金](https://aws.amazon.com/kms/pricing)を参照してください。
IAM ユーザーが KMS で暗号化されたバケットにアクセスできるようにする手順については、「[私の Amazon S3 バケットにはカスタムの AWS KMS キーを使用したデフォルト暗号化が設定されています」を参照してください。ユーザーがそのバケットでダウンロードやアップロードを行えるようにするにはどうすればいいですか](https://repost.aws/knowledge-center/s3-bucket-access-default-encryption)」を AWS re:Post 情報センターで参照してください。
**アクセス許可**
AWS KMS キーを使用して、オブジェクトを Amazon S3 に暗号化する `PutObject` リクエストを正常に実行するには、キーに対する `kms:GenerateDataKey` アクセス許可が必要です。AWS KMS key を使用して暗号化されたオブジェクトをダウンロードするには、キーに対して `kms:Decrypt` の許可が必要です。[マルチパートアップロードを実行](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions)して AWS KMS key でオブジェクトを暗号化するには、キーの `kms:GenerateDataKey` および `kms:Decrypt` アクセス許可が必要です。
**重要**
KMS キーポリシーで付与されているアクセス権限を慎重に確認します。カスタマーマネージド AWS KMS キーのポリシーのアクセス許可は常に、関連するキーアクションにアクセスする必要がある IAM プリンシパルと AWS サービスのみに限定する必要があります。詳細については、「[AWS KMS のキーポリシー](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)」を参照してください。
**Topics**
+ [
## AWS KMS keys
](#aws-managed-customer-managed-keys)
+ [
## Amazon S3 バケットキー
](#sse-kms-bucket-keys)
+ [
## サーバー側の暗号化の要求
](#require-sse-kms)
+ [
## 暗号化コンテキスト
](#encryption-context)
+ [
## AWS KMS 暗号化されたオブジェクトへのリクエストの送信
](#aws-signature-version-4-sse-kms)
+ [
# AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定
](specifying-kms-encryption.md)
+ [
# Amazon S3 バケットキーを使用した SSE−KMS のコストの削減
](bucket-key.md)
## AWS KMS keys
AWS KMS によるサーバー側暗号化 (SSE-KMS) を使用すると、デフォルトの [AWS マネージドキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)を使用するか、または、作成済みの[カスタマーマネージドキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)を指定できます。AWS KMS は*エンベロープ暗号化*をサポートします。S3 は、*エンベロープ暗号化*の AWS KMS 機能を使用してデータを保護します。エンベロープ暗号化は、データキーでプレーンテキストデータを暗号化してから、そのデータキーを KMS キーで暗号化する手法です。エンベロープ暗号化の仕組みの詳細については、*AWS Key Management Service デベロッパーガイド*の「[エンベロープ暗号化](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#enveloping)」を参照してください。
カスタマーマネージドキーを指定しない場合、SSE−KMS で暗号化されたオブジェクトをバケットに初めて追加するとき、Amazon S3 によって自動的に AWS アカウント に AWS マネージドキー が作成されます。デフォルトでは、Amazon S3 はこの KMS キーを SSE−KMS に使用します。
**注記**
SSE-KMS を [AWS マネージドキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) で使用して暗号化されたオブジェクトは、クロスアカウントで共有できません。SSE-KMS データをアカウント間で共有する必要がある場合は、AWS KMS の[カスタマーマネージドキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)を使用する必要があります。
SSE−KMS にカスタマーマネージドキーを使用する場合は、SSE−KMS を設定する前に対称暗号化カスタマーマネージドキーを作成します。次に、バケット用に SSE−KMS を設定するときに、既存のカスタマーマネージドキーを指定します。対象暗号化キーの詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
カスタマーマネージドキーを独自に作成することで、より柔軟に制御を行えます。例えば、カスタマーマネージドキーを作成、ローテーション、無効化することができます。また、アクセスコントロールを定義し、データを保護するために使用するカスタマーマネージドキーを監査することもできます。カスタマーマネージドキーおよび AWS マネージドキーの詳細については、「*AWS Key Management Service デベロッパーガイド*」の「[カスタマーキーおよび AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
**注記**
標準の KMS キーとは異なり、外部のキーストアに保存されているカスタマーマネージドキーによるサーバー側の暗号化を使用する場合は、キーマテリアルの可用性と耐久性を確保する責任があります。外部キーストアと、それらによって責任分担モデルがどのように変化するかについての詳細は、「*AWS Key Management Service デベロッパーガイド*」の「[外部キーストア](https://docs.aws.amazon.com//kms/latest/developerguide/keystore-external.html)」を参照してください。
### クロスアカウント操作での SSE-KMS 暗号化の使用
クロスアカウント操作で暗号化を使用する場合は、次の点に注意してください。
+ リクエスト時またはバケットのデフォルトの暗号化設定を通じて、AWS KMS key Amazon リソースネーム (ARN) またはエイリアスが提供されない場合は、アップロードアカウントの AWS マネージドキー (`aws/s3`) が暗号化に使用され、復号化に必要になります。
+ AWS マネージドキー (`aws/s3`) は、アップロードとアクセス AWS Identity and Access Management (IAM) プリンシパルが同じ AWS アカウントである場合、クロスアカウントオペレーションの KMS キーとして使用できます。
+ S3 オブジェクトにクロスアカウントアクセスを許可する場合は、カスタマーマネージドキーを使用します。カスタマーマネージドキーのポリシーを設定して、別のアカウントからのアクセスを許可することができます。
+ カスタマーマネージド KMS キーを指定している場合、完全修飾 KMS キー ARN を使用することをお勧めします。代わりに KMS キーエイリアスを使用する場合、AWS KMS はリクエスタのアカウント内でキーを解決します。この動作により、バケット所有者ではなく、リクエスタに属する KMS キーでデータが暗号化される可能性があります。
+ お客様 (リクエスタ) が `Encrypt` アクセス許可を付与されているキーを指定する必要があります。詳細については、*AWS Key Management Service デベロッパーガイド*の「[キーユーザーが暗号化オペレーションに KMS キーを使用することを許可する](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-users-crypto)」を参照してください。
カスタマーマネージドキーと AWS マネージド KMS キーをどのような場合に使用するかの詳細については、「[Amazon S3 にあるオブジェクトの暗号化に AWS マネージドキー、またはカスタマーマネージドキーを使うべきですか](https://aws.amazon.com/premiumsupport/knowledge-center/s3-object-encryption-keys/)」を参照してください。
### SSE-KMS 暗号化ワークフロー
AWS マネージドキー またはカスタマーマネージドキーを使用してデータの暗号化を選択する場合は、AWS KMS および Amazon S3 は次のエンベロープ暗号化アクションを実行します。
1. Amazon S3 は、プレーンテキストの[データキー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#data-keys)および指定された KMS キーで暗号化されたキーのコピーをリクエストします。
1. AWS KMS は、データキーを生成し、KMS キーで暗号化して、プレーンテキストデータキーと暗号化されたデータキーの両方を Amazon S3 に送信します。
1. Amazon S3 は、データキーを使用してデータを暗号化し、使用後はメモリからプレーンテキストのキーをできる限り迅速に削除します。
1. Amazon S3 は、暗号化されたデータキーを、暗号化されたデータのメタデータとして保存します。
データの復号をリクエストすると、Amazon S3 と AWS KMS は次のアクションを実行します。
1. `Decrypt` リクエストがあると、Amazon S3 は暗号化されたデータキーを AWS KMS に送信します。
1. AWS KMS は、同じ KMS キーを使用して暗号化データキーを復号し、プレーンテキストのデータキーを Amazon S3 に返します。
1. Amazon S3 は、プレーンテキストデータキーを使用して暗号化されたデータを復号し、できるだけ早くプレーンテキストデータキーをメモリから削除します。
**重要**
Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 は、対称暗号化 KMS キーのみをサポートします。このキーの詳細については、「**AWS Key Management Service デベロッパーガイド」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
### SSE-KMS 暗号化の監査
SSE-KMS を指定するリクエストを識別するには、Amazon S3 ストレージレンズメトリクスの「**すべての SSE-KMS リクエスト**」と「**すべての SSE-KMS リクエストの割合 (%)**」メトリクスを使用できます。S3 ストレージレンズは、オブジェクトストレージの使用状況とアクティビティを組織全体で可視化するために使用できるクラウドストレージ分析機能です。SSE-KMS 対応バケット数と % SSE-KMS 対応バケットを使用して、[デフォルトのバケット暗号化](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html) のバケット数 (SSE-KMS) を把握することもできます。詳細については、「[S3 Storage Lens を使用したストレージのアクティビティと使用状況の評価](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens.html?icmpid=docs_s3_user_guide_UsingKMSEncryption.html)」を参照してください。メトリクスの完全なリストについては、「[S3 ストレージレンズメトリクスに関する用語集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens_metrics_glossary.html?icmpid=docs_s3_user_guide_UsingKMSEncryption.html)」を参照してください。
SSE-KMS で暗号化されたデータの AWS KMS キーの使用状況を監査するには、AWS CloudTrail ログを使用します。[https://docs.aws.amazon.com/kms/latest/developerguide/ct-generatedatakey.html](https://docs.aws.amazon.com/kms/latest/developerguide/ct-generatedatakey.html) や [https://docs.aws.amazon.com/kms/latest/developerguide/ct-decrypt.html](https://docs.aws.amazon.com/kms/latest/developerguide/ct-decrypt.html) などの[暗号化オペレーション](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#cryptographic-operations)に関するインサイトを得ることができます。CloudTrail は、イベント名、ユーザー名、イベントソースなど、検索をフィルタリングするための多数の[属性値](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_LookupEvents.html)をサポートしています。
## Amazon S3 バケットキー
AWS KMS (SSE−KMS) を使用してサーバー側の暗号化を設定する場合、SSE−KMS で S3 バケットキーを使用するようにバケットを設定できます。SSE-KMS でこのバケットレベルのキーを使用すると、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS KMS のリクエストコストを最大 99% 削減できます。
新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定すると、AWS KMS によりバケットレベルのキーが生成されます。このキーは、バケット内のオブジェクトの一意の[データキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)を作成するために使用されます。この S3 バケットキーは Amazon S3 内で期間限定で使用されるため、Amazon S3 で AWS KMS にリクエストを実行し、暗号化オペレーションを完了する必要性が軽減されます。S3 バケットキーの使用の詳細については、[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md) を参照してください。
## サーバー側の暗号化の要求
特定の Amazon S3 バケット内のすべてのオブジェクトのサーバー側の暗号化を要求するには、バケットポリシーを使用できます。例えば、SSE-KMS を使用したサーバー側の暗号化を要求する `x-amz-server-side-encryption-aws-kms-key-id` ヘッダーがリクエストに含まれていない場合、次のバケットポリシーはすべてのユーザーに対し、オブジェクト (`s3:PutObject`) をアップロードするアクセス許可を拒否します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id":"PutObjectPolicy",
"Statement":[{
"Sid":"DenyObjectsThatAreNotSSEKMS",
"Effect":"Deny",
"Principal":"*",
"Action":"s3:PutObject",
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket1/*",
"Condition":{
"Null":{
"s3:x-amz-server-side-encryption-aws-kms-key-id":"true"
}
}
}
]
}
```
------
特定の AWS KMS key を使用してバケット内のオブジェクトを暗号化することを要求するには、`s3:x-amz-server-side-encryption-aws-kms-key-id` 条件キーを使用できます。KMS キーを指定するには、キーの Amazon リソースネーム (ARN) を `arn:aws:kms:region:acct-id:key/key-id` 形式で使用する必要があります。AWS Identity and Access Management は、`s3:x-amz-server-side-encryption-aws-kms-key-id` の文字列が存在するかどうかを検証しません。
**注記**
オブジェクトをアップロードするときは、`x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを使用して KMS キーを指定するか、[デフォルトのバケット暗号化設定](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html)を使用できます。PutObject リクエストで `x-amz-server-side-encryption` ヘッダーに `aws:kms` を指定し、`x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを指定しないと、AWS マネージドキーを使用するものと仮定されます。その場合でも、Amazon S3 がオブジェクトの暗号化に使用する AWS KMS キー ID とポリシーの AWS KMS キー ID は一致する必要があります。一致しない場合、Amazon S3 はリクエストを拒否します。
Amazon S3 固有の条件キーの完全なリストについては、「サービス認可リファレンス」の「[Condition keys for Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html#amazons3-policy-keys)」を参照してください。**
## 暗号化コンテキスト
*暗号化コンテキスト*は、データに関する追加のコンテキスト情報が含まれたキーと値のペアのセットです。この暗号化コンテキストは暗号化されていません。暗号化オペレーションで暗号化コンテキストを指定すると、Amazon S3 では同じ暗号化コンテキストを復号オペレーションに指定する必要があります。そうでない場合は、復号に失敗します。AWS KMS は、暗号化コンテキストを[追加の認証データ](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/concepts.html#digital-sigs) (AAD) として使用し、[認証された暗号化](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#cryptographic-operations#digital-sigs)をサポートします。暗号化コンテキストの詳細については、「*AWS Key Management Service デベロッパーガイド*」の[「暗号化コンテキスト」](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)を参照してください。
デフォルトでは、Amazon S3 は、オブジェクトまたはバケットの Amazon リソースネーム (ARN) を暗号化コンテキストペアとして使用します。
+ **S3 バケットキーを有効にせずに SSE-KMS を使用する場合は**、オブジェクト ARN を暗号化コンテキストとして使用します。
```
arn:aws:s3:::object_ARN
```
+ **S3 バケットキーを有効にして SSE-KMS を使用する場合は**、暗号化コンテキストとしてバケット ARN を使用します。S3 バケットキーの詳細については、[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md) を参照してください。
```
arn:aws:s3:::bucket_ARN
```
[s3:PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject_RequestSyntax) リクエストの `x-amz-server-side-encryption-context` のヘッダーを使って、オプションで追加の暗号化コンテキストペアを指定することができます。しかし、暗号化コンテキストは暗号化されないため、機密情報を含めないでください。Amazon S3 は、この追加のキーペアをデフォルトの暗号化コンテキストとともに保存します。`PUT` リクエストを処理すると、Amazon S3 は `aws:s3:arn` のデフォルトの暗号化コンテキストを、指定するものに追加します。
暗号化コンテキストを使用して、暗号化オペレーションを識別および分類できます。デフォルトの暗号化コンテキスト ARN 値を使用して、どの Amazon S3 ARN がどの暗号化キーで使用されたかを確認することで、AWS CloudTrail の関連するリクエストを追跡することもできます。
CloudTrail ログファイルの `requestParameters` フィールドでは、暗号化コンテキストは次のようになります。
```
"encryptionContext": {
"aws:s3:arn": "arn:aws:s3:::amzn-s3-demo-bucket1/file_name"
}
```
SSE−KMS をオプションの S3 バケットキー機能とともに使用すると、暗号化コンテキストの値はバケットの ARN になります。
```
"encryptionContext": {
"aws:s3:arn": "arn:aws:s3:::amzn-s3-demo-bucket1"
}
```
## AWS KMS 暗号化されたオブジェクトへのリクエストの送信
**重要**
AWS KMS により暗号化されたオブジェクトに対するすべての `GET` および `PUT` リクエストは、Secure Sockets Layer (SSL) または Transport Layer Security (TLS) を使用して生成する必要があります。また、各リクエストは、AWS 署名バージョン 4 (または AWS 署名バージョン 2) のような有効な認証情報を使用して署名する必要もあります。
AWS Signature Version 4 は、HTTP で送信される AWS リクエストに認証情報を追加するプロセスです。セキュリティ対策として、AWS へのほとんどのリクエストは、アクセスキーを使用して署名する必要があります。アクセスキーは、アクセスキー ID とシークレットアクセスキーで構成されます。これらの 2 つのキーは、一般的にセキュリティ認証情報と呼ばれます。詳細については、「[リクエストの認証 (AWS 署名バージョン 4)](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html)」および「[署名バージョン 4 の署名プロセス](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)」を参照してください。
**重要**
オブジェクトで SSE−KMS を使用している場合、`GET` リクエストおよび `HEAD` リクエストに対して暗号化リクエストヘッダーを送信しないでください。そうしないと、HTTP 400 Bad Request エラーが表示されます。
**Topics**
+ [
## AWS KMS keys
](#aws-managed-customer-managed-keys)
+ [
## Amazon S3 バケットキー
](#sse-kms-bucket-keys)
+ [
## サーバー側の暗号化の要求
](#require-sse-kms)
+ [
## 暗号化コンテキスト
](#encryption-context)
+ [
## AWS KMS 暗号化されたオブジェクトへのリクエストの送信
](#aws-signature-version-4-sse-kms)
+ [
# AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定
](specifying-kms-encryption.md)
+ [
# Amazon S3 バケットキーを使用した SSE−KMS のコストの削減
](bucket-key.md)
# AWS KMS (SSE−KMS) によるサーバー側の暗号化の指定
すべての Amazon S3 バケットにはデフォルトで暗号化が設定されており、S3 バケットにアップロードされたすべての新しいオブジェクトは保存時に自動的に暗号化されます。Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) は、Amazon S3 のすべてのバケットでのデフォルトの暗号化設定です。別のタイプの暗号化を使用するには、S3 `PUT` リクエストで使用するサーバー側の暗号化のタイプを指定するか、宛先バケットにデフォルトの暗号化設定を更新できます。
`PUT` リクエストで別の暗号化タイプを指定する場合は、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS)、AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS)、または顧客提供のキーによるサーバー側の暗号化 (SSE-C) を使用できます。宛先バケットに別のデフォルト暗号化設定を設定する場合は、SSE-KMS または DSSE-KMS を使用できます。
汎用バケットのデフォルトの暗号化設定を変更する方法の詳細については、「[デフォルトの暗号化の設定](default-bucket-encryption.md)」を参照してください。
バケットのデフォルトの暗号化設定を SSE-KMS に変更しても、バケット内の既存の Amazon S3 オブジェクトの暗号化タイプは変更されません。デフォルトの暗号化設定を SSE-KMS に更新した後に既存のオブジェクトの暗号化タイプを変更するには、Amazon S3 バッチオペレーションを使用できます。S3 バッチオペレーションにオブジェクトのリストを指定すると、バッチオペレーションが対応する API オペレーションを呼び出します。[オブジェクトのコピー](batch-ops-copy-object.md) アクションを使用して既存のオブジェクトをコピーし、SSE-KMS で暗号化されたオブジェクトと同じバケットに書き戻すことができます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、「[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md)」および *AWS Storage Blog* の投稿「[How to retroactively encrypt existing objects in Amazon S3 using S3 Inventory, Amazon Athena, and S3 Batch Operations](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)」を参照してください。
Amazon S3 コンソール、REST API オペレーション、AWS SDK、および AWS Command Line Interface (AWS CLI) を使用して SSE-KMS を指定できます。詳細については、以下のトピックを参照してください。
**注記**
Amazon S3 では、マルチリージョン AWS KMS keys を使用できます。ただし、Amazon S3 では現在、マルチリージョンキーは、単一リージョンキーであるかのように処理され、キーのマルチリージョン特徴は使用しません。詳細については、「AWS Key Management Service デベロッパーガイド」の「[Using multi-Region keys](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)」を参照してください。**
**注記**
別のアカウントが所有している KMS キーを使用する場合は、そのキーを使用するアクセス許可が必要です。KMS キーのクロスアカウント権限の詳細については、*AWS Key Management Service デベロッパーガイド*の「[他のアカウントで使用できる KMS キーを作成する](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)」を参照してください。
## S3 コンソールの使用
このトピックでは、Amazon S3 コンソールを使用して、AWS Key Management Service (AWS KMS) キーによるサーバー側の暗号化 (SSE-KMS) を使用するようにオブジェクトの暗号化のタイプを設定または変更する方法について説明します。
**注記**
オブジェクトが 5 GB 未満の場合は、オブジェクトの暗号化を変更できます。オブジェクトが 5 GB を超える場合は、[AWS CLI](mpu-upload-object.md#UsingCLImpUpload) または [AWS SDK](CopyingObjectsMPUapi.md) を使用してオブジェクトの暗号化を変更する必要があります。
オブジェクトの暗号化の変更に必要な追加のアクセス許可のリストについては、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。このアクセス許可を付与するポリシーの例については、「[Amazon S3 のアイデンティティベースのポリシー例](example-policies-s3.md)」を参照してください。
オブジェクトの暗号化を変更すると、新しいオブジェクトが作成され、古いオブジェクトが置き換えられます。S3 バージョニングが有効になっている場合は、オブジェクトの新しいバージョンが作成され、既存のオブジェクトが古いバージョンになります。また、プロパティを変更するロールは、新しいオブジェクト (またはオブジェクトのバージョン) の所有者になります。
**オブジェクトの暗号化を追加または変更するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. ナビゲーションペインで **[バケット]** を選択してから、**[汎用バケット]** タブをクリックします。変更するオブジェクトを含む Amazon S3 バケットまたはフォルダに移動します。
1. 変更するオブジェクトのチェックボックスをオンにします。
1. **[アクション]** メニューに表示されるオプションのリストから **[サーバー側の暗号化を編集]** を選択します。
1. **[サーバー側の暗号化]** セクションまでスクロールします。
1. **[暗号化設定]** で、**[デフォルトの暗号化にバケット設定を使用する]** または **[デフォルトの暗号化にバケット設定を上書きする]** を選択します。
**重要**
デフォルト暗号化設定に SSE-KMS オプションを使用する場合、AWS KMS の 1 秒あたりのリクエスト (RPS) 制限が適用されます。AWS KMS クォータの詳細およびクォータの引き上げをリクエストする方法については、*AWS Key Management Service デベロッパーガイド*の「[クォータ](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)」を参照してください。
1. **[デフォルトの暗号化にバケット設定を上書きする]** を選択した場合は、次の暗号化設定を設定します。
1. **[暗号化タイプ]** で、**[AWS Key Management Service キーによるサーバー側の暗号化 (SSE-KMS)]** を選択します。
1. **[AWS KMS キー]** で、次のいずれかを実行して KMS キーを選択します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS** キーを選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
**重要**
バケットと同じ AWS リージョン で使用可能な KMS キーのみを使用できます。Amazon S3 コンソールには、バケットと同じリージョンで最初の 100 個の KMS キーしか表示されません。リストに存在しない KMS キーを使用するには、KMS キー ARN を入力する必要があります。別のアカウントが所有している KMS キーを使用する場合は、まずそのキーを使用するアクセス許可が必要であり、次に KMS キー ARN を入力する必要があります。
Amazon S3 では、対称暗号化 KMS キーのみがサポートされ、非対称暗号化 KMS キーはサポートされません。詳細については、*AWS Key Management Service デベロッパーガイド*の「[Identifying symmetric and asymmetric KMS keys](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html)」(対称および非対称 KMS キーの識別) を参照してください。
1. **[追加のコピー設定]** で、**[ソース設定をコピー]** するか、**[設定を指定しない]** か、**[設定を指定]** するかを選択します。**[ソース設定をコピー]** がデフォルトのオプションです。ソース設定の属性なしでオブジェクトのみをコピーする場合は、**[設定を指定しない]** を選択します。ストレージクラス、ACL、オブジェクトタグ、メタデータ、サーバー側の暗号化、その他のチェックサムの設定を指定するには、**[設定を指定]** を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
**注記**
このアクションは、指定されたすべてのオブジェクトに暗号化を適用します。フォルダを暗号化する場合は、保存オペレーションが完了するのを待ってから、フォルダに新しいオブジェクトを追加します。
## REST API の使用
オブジェクトを作成するとき (新しいオブジェクトをアップロードするか、既存のオブジェクトをコピーするとき) に、AWS KMS keys (SSE-KMS) を使用したサーバー側の暗号化の使用を指定してデータを暗号化できます。これを行うには、リクエストに `x-amz-server-side-encryption` ヘッダーを追加します。ヘッダーの値を、暗号化アルゴリズム `aws:kms` に設定します。Amazon S3 によりレスポンスヘッダー `x-amz-server-side-encryption` が返されるため、SSE−KMS を使用してオブジェクトが保存されたことを確認できます。
`x-amz-server-side-encryption` の値で `aws:kms` ヘッダーを指定する場合は、次のリクエストヘッダーも使用できます。
+ `x-amz-server-side-encryption-aws-kms-key-id`
+ `x-amz-server-side-encryption-context`
+ `x-amz-server-side-encryption-bucket-key-enabled`
**Topics**
+ [
### SSE-KMS をサポートする Amazon S3 REST API オペレーション
](#sse-request-headers-kms)
+ [
### 暗号化コンテキスト (`x-amz-server-side-encryption-context`)
](#s3-kms-encryption-context)
+ [
### AWS KMS キー ID (`x-amz-server-side-encryption-aws-kms-key-id`)
](#s3-kms-key-id-api)
+ [
### S3 バケットキー (`x-amz-server-side-encryption-aws-bucket-key-enabled`)
](#bucket-key-api)
### SSE-KMS をサポートする Amazon S3 REST API オペレーション
次の REST API オペレーションでは `x-amz-server-side-encryption`、`x-amz-server-side-encryption-aws-kms-key-id`、および `x-amz-server-side-encryption-context` リクエストヘッダーを受け入れます。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) - `PUT` オペレーションを使用してデータをアップロードするとき、これらのリクエストヘッダーを指定できます。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) — オブジェクトをコピーするときには、ソースオブジェクトとターゲットオブジェクトの両方があります。`CopyObject` オペレーションで SSE−KMS ヘッダーを渡す場合は、ターゲットオブジェクトにのみ適用されます。既存のオブジェクトをコピーする際は、コピー元オブジェクトが暗号化されているかどうかに関係なく、明示的にサーバー側の暗号化を要求しない限り、コピー先オブジェクトは暗号化されません。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) — `POST` オペレーションを使用してオブジェクトをアップロードするときには、リクエストヘッダーの代わりに、フォームフィールドで同じ情報を指定します。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) — マルチパートアップロード API オペレーションを使用して大きいオブジェクトをアップロードする場合、これらのヘッダーを指定できます。これらのヘッダーを `CreateMultipartUpload` リクエストで指定します。
次の REST API オペレーションのレスポンスヘッダーは、オブジェクトがサーバー側の暗号化を使用して保存されているときに `x-amz-server-side-encryption` ヘッダーを返します。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)
**重要**
AWS KMS で保護されたオブジェクトに対する `GET` リクエストと `PUT` リクエストはすべて、Secure Sockets Layer (SSL)、Transport Layer Security (TLS)、または署名バージョン 4 を使用していない場合、失敗します。
オブジェクトで SSE−KMS を使用している場合、`GET` リクエストおよび `HEAD` リクエストに対して暗号化リクエストヘッダーを送信しないでください。送信すると、HTTP 400 BadRequest エラーが発生します。
### 暗号化コンテキスト (`x-amz-server-side-encryption-context`)
`x-amz-server-side-encryption:aws:kms` を指定した場合、Amazon S3 API は `x-amz-server-side-encryption-context` ヘッダーの暗号化コンテキストをサポートします。暗号化コンテキストは、データに関する追加のコンテキスト情報が含まれたキーバリューペアのセットです。
Amazon S3 は、オブジェクトまたはバケットの Amazon リソースネーム (ARN) を暗号化コンテキストペアとして自動的に使用します。S3 バケットキーを有効にせずに SSE−KMS を使用する場合は、オブジェクト ARN を暗号化コンテキストとして使用します。例えば、`arn:aws:s3:::object_ARN` です。ただし、S3 バケットキーを有効にして SSE−KMS を使用する場合は、バケット ARN を暗号化コンテキストに使用します。例えば、`arn:aws:s3:::bucket_ARN` です。
オプションで、`x-amz-server-side-encryption-context` ヘッダーを使用して、追加の暗号化コンテキストペアを指定することもできます。しかし、暗号化コンテキストは暗号化されないため、機密情報を含めないでください。Amazon S3 は、この追加のキーペアをデフォルトの暗号化コンテキストとともに保存します。
Amazon S3 の暗号化コンテキストの詳細については、「[暗号化コンテキスト](UsingKMSEncryption.md#encryption-context)」を参照してください。暗号化コンテキストの一般的な情報については、**「AWS Key Management Service デベロッパーガイド」の「[AWS Key Management Service Concepts - Encryption context](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)」を参照してください。
### AWS KMS キー ID (`x-amz-server-side-encryption-aws-kms-key-id`)
`x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを使用して、データの保護に使用するカスタマーマネージドキーの ID を指定できます。`x-amz-server-side-encryption:aws:kms` ヘッダーを指定しても `x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを指定しない場合、Amazon S3 は AWS マネージドキー (`aws/s3`) を使用してデータを保護します。カスタマーマネージドキーを使用する場合は、カスタマーマネージドキーの `x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを指定する必要があります。
**重要**
Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 は、対称暗号化 KMS キーのみをサポートします。このキーの詳細については、「**AWS Key Management Service デベロッパーガイド」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
### S3 バケットキー (`x-amz-server-side-encryption-aws-bucket-key-enabled`)
`x-amz-server-side-encryption-aws-bucket-key-enabled` リクエストヘッダーを使用して、オブジェクトレベルで S3 バケットキーを有効または無効にできます。S3 バケットキーで、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS KMS リクエストコストを削減できます。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
`x-amz-server-side-encryption:aws:kms` ヘッダーを指定しても、`x-amz-server-side-encryption-aws-bucket-key-enabled` は指定しない場合、オブジェクトは送信先バケットの S3 バケットキーの設定を使用して、オブジェクトを暗号化します。詳細については、「[オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)」を参照してください。
## AWS CLI の使用
次の AWS CLI コマンド例を使用する際は、`user input placeholders` をユーザー自身の情報に置き換えます。
新しいオブジェクトをアップロードするか、既存のオブジェクトをコピーするときに、AWS KMS キーを使用したサーバー側の暗号化の使用を指定してデータを暗号化できます。これを行うには、リクエストに `--server-side-encryption aws:kms` ヘッダーを追加します。`--ssekms-key-id example-key-id`を使用して、作成した[カスタマーマネージド AWS KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#customer-cmk)を追加します。AWS KMS キー ID を指定せずに `--server-side-encryption aws:kms` を指定した場合、Amazon S3 は AWS マネージドキーを使用します。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms --ssekms-key-id example-key-id --body filepath
```
さらに、`--bucket-key-enabled` または `--no-bucket-key-enabled` を追加することで、PUT または COPY オペレーションで Amazon S3 バケットキーを有効または無効にできます。S3 バケットキーで、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS KMS リクエストコストを削減できます。詳細については、「[Amazon S3 バケットキーを使用した SSE-KMS のコストの削減](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-key.html)」を参照してください。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms --bucket-key-enabled --body filepath
```
暗号化されていないオブジェクトを元の場所にコピーすることで、SSE-KMS を使用するように暗号化できます。
```
aws s3api copy-object --bucket amzn-s3-demo-bucket --key example-object-key --body filepath --bucket amzn-s3-demo-bucket --key example-object-key --sse aws:kms --sse-kms-key-id example-key-id --body filepath
```
## AWS SDK の使用
AWS SDK を使用する場合、サーバー側の暗号化に AWS KMS keys を使用するよう Amazon S3 にリクエストできます。次の例は、AWS SDK for Java および .NET で SSE-KMS を使用する方法を示しています。他の SDK については、AWS デベロッパーセンターの[サンプルコードとライブラリ](https://aws.amazon.com/code)を参照してください。
**重要**
Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 は、対称暗号化 KMS キーのみをサポートします。このキーの詳細については、「**AWS Key Management Service デベロッパーガイド」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
### `CopyObject` オペレーション
オブジェクトをコピーする場合は、同じリクエストプロパティ (`ServerSideEncryptionMethod` および `ServerSideEncryptionKeyManagementServiceKeyId`) を追加して、AWS KMS key を使用するように Amazon S3 に対してリクエストします。オブジェクトのコピーの詳細については、[オブジェクトのコピー、移動、名前の変更](copy-object.md) を参照してください。
### `PUT` オペレーション
------
#### [ Java ]
AWS SDK for Java を使用してオブジェクトをアップロードする場合、次のリクエストのように `SSEAwsKeyManagementParams` プロパティを追加することによって、AWS KMS key を使用するように Amazon S3 に対してリクエストできます。
```
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName, file).withSSEAwsKeyManagementParams(new SSEAwsKeyManagementParams());
```
この場合、Amazon S3 は AWS マネージドキー (`aws/s3`) を使用します。詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。次の例に示すように、オプションで、対称暗号化 KMS キーを作成し、それをリクエストで指定できます。
```
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName, file).withSSEAwsKeyManagementParams(new SSEAwsKeyManagementParams(keyID));
```
カスタマーマネージドキーの作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[AWS KMS API のプログラミング](https://docs.aws.amazon.com/kms/latest/developerguide/programming-top.html)」を参照してください。
オブジェクトをアップロードするためのコード例については、以下のトピックを参照してください。これらの例を使用するには、コード例を更新し、前出のコード例に示されているように暗号化情報を提供する必要があります。
+ 1 つのオペレーションでオブジェクトをアップロードする場合は、[オブジェクトのアップロード](upload-objects.md) を参照してください。
+ 高レベルまたは低レベルのマルチパートアップロード API オペレーションを使用するマルチパートアップロードについては、「[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md)」を参照してください。
------
#### [ .NET ]
AWS SDK for .NET を使用してオブジェクトをアップロードする場合、次のリクエストのように `ServerSideEncryptionMethod` プロパティを追加することによって、AWS KMS key を使用するように Amazon S3 に対してリクエストできます。
```
PutObjectRequest putRequest = new PutObjectRequest
{
BucketName = amzn-s3-demo-bucket,
Key = keyName,
// other properties
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS
};
```
この場合、Amazon S3 は AWS マネージドキー を使用します。詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。次の例に示すように、オプションで、独自の対称暗号化カスタマーマネージドキーを作成し、それをリクエストで指定できます。
```
PutObjectRequest putRequest1 = new PutObjectRequest
{
BucketName = amzn-s3-demo-bucket,
Key = keyName,
// other properties
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
ServerSideEncryptionKeyManagementServiceKeyId = keyId
};
```
カスタマーマネージドキーの作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[AWS KMS API のプログラミング](https://docs.aws.amazon.com/kms/latest/developerguide/programming-top.html)」を参照してください。
オブジェクトをアップロードするためのコード例については、以下のトピックを参照してください。これらの例を使用するには、コード例を更新し、前出のコード例に示されているように暗号化情報を提供する必要があります。
+ 1 つのオペレーションでオブジェクトをアップロードする場合は、[オブジェクトのアップロード](upload-objects.md) を参照してください。
+ 高レベルまたは低レベルのマルチパートアップロード API オペレーションを使用するマルチパートアップロードについては、「[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md)」を参照してください。
------
### 署名付き URL
------
#### [ Java ]
次の例に示すように、AWS KMS key で暗号化されたオブジェクトの署名付き URL を作成する際には、署名バージョン 4 を明示的に指定する必要があります。
```
ClientConfiguration clientConfiguration = new ClientConfiguration();
clientConfiguration.setSignerOverride("AWSS3V4SignerType");
AmazonS3Client s3client = new AmazonS3Client(
new ProfileCredentialsProvider(), clientConfiguration);
...
```
コード例については、[署名付き URL を使用したオブジェクトの共有](ShareObjectPreSignedURL.md) を参照してください。
------
#### [ .NET ]
次の例に示すように、AWS KMS key で暗号化されたオブジェクトの署名付き URL を作成する際には、署名バージョン 4 を明示的に指定する必要があります。
```
AWSConfigs.S3Config.UseSignatureVersion4 = true;
```
コード例については、[署名付き URL を使用したオブジェクトの共有](ShareObjectPreSignedURL.md) を参照してください。
------
# Amazon S3 バケットキーを使用した SSE−KMS のコストの削減
Amazon S3 バケットキーは、AWS Key Management Service (AWS KMS) を使用した Amazon S3 サーバー側の暗号化のコストを削減します。SSE-KMS でこのバケットレベルのキーを使用すると、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS KMS のリクエストコストを最大 99% 削減できます。AWS マネジメントコンソール を数回クリックするだけで、クライアントアプリケーションの変更はせずにバケットを設定し、新しいオブジェクトで SSE-KMS の暗号化に S3 バケットキーを使用することができます。
**注記**
S3 バケットキーは、AWS Key Management Service (AWS KMS) キーによる二層式サーバー側の暗号化 (DSSE-KMS) ではサポートされていません。
## SSE−KMS の S3 バケットキー
SSE−KMS で暗号化された数百万、数十億のオブジェクトにアクセスするワークロードは、AWS KMS に大量のリクエストを生成します。S3 バケットキーなしで SSE−KMS を使用してデータを保護する場合、Amazon S3 はすべてのオブジェクトに対して個々の AWS KMS [データキー](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)を使用します。この場合、KMS で暗号化されたオブジェクトに対してリクエストが実行されるたびに、Amazon S3 は AWS KMS を呼び出します。SSE−KMS の仕組みについては、[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md) を参照してください。
SSE-KMS の S3 バケットキーを使用するようにバケットを設定すると、AWS は AWS KMS から有効期限の短いバケットレベルのキーを生成し、S3 に一時的に保存します。このバケットレベルのキーは、ライフサイクル中に新しいオブジェクトのデータキーを作成します。S3 バケットキーは Amazon S3 内で期間限定で使用されるため、S3 で AWS KMS にリクエストを実行し、暗号化オペレーションを完了する必要性が軽減されます。これにより S3 から AWS KMS へのトラフィックが減少し、これまでと比較してわずかなコストで、Amazon S3 の AWS KMS で暗号化されたオブジェクトにアクセスできるようになります。
固有のバケットレベルのキーはリクエスタごとに少なくとも 1 回フェッチされ、キーへのリクエスターのアクセスが AWS KMS CloudTrail イベントで確実にキャプチャされます。Amazon S3 は、呼び出し元が異なるロールまたはアカウントを使用する場合、または同じロールを異なるスコープポリシーで使用する場合、呼び出し元を異なるリクエスタとして扱います。AWS KMS リクエスト削減数は、リクエスタ数、リクエストパターン、リクエストされたオブジェクトの相対的な経過時間を反映しています。例えば、リクエスタの数が少なく、限られた時間枠で複数のオブジェクトをリクエストして、同じバケットレベルのキーで暗号化した場合、大幅な削減につながります。
**注記**
S3 バケットキーを使用すると、バケットレベルのキーを使って `Encrypt`、`GenerateDataKey`、`Decrypt` オペレーションの AWS KMS リクエスト数を減らし、AWS KMS リクエストのコストを節約できます。設計上、このバケットレベルのキーを利用する後続のリクエストが AWS KMS API リクエストになったり、AWS KMS キーポリシーに照らしてアクセスが検証されたりすることはありません。
S3 バケットキーを設定する場合、バケット内に既に存在するオブジェクトは S3 バケットキーを使用しません。既存のオブジェクトの S3 バケットキーを設定するには、`CopyObject` オペレーションを使用できます。詳細については、「[オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)」を参照してください。
Amazon S3 は、同じ AWS KMS key で暗号化されるオブジェクトの S3 バケットキーのみを共有します。S3 バケットキーは、AWS KMS によって作成された KMS キー、[インポートされたキーマテリアル](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html)、および[カスタムキーストア によってバックアップされたキーマテリアル](https://docs.aws.amazon.com/kms/latest/developerguide/custom-key-store-overview.html)と互換性があります。
![\[バケット内のオブジェクトのデータキーを作成するバケットキーを生成する AWS KMS を説明する図\]](http://docs.aws.amazon.com/ja_jp/AmazonS3/latest/userguide/images/S3-Bucket-Keys.png)
## S3 バケットキーの設定
Amazon S3 コンソール、AWS SDK、AWS CLI、または REST API を使用して、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定できます。バケットで S3 バケットキーを有効にすると、別の指定した SSE-KMS キーでアップロードされたオブジェクトは、独自の S3 バケットキーを使用します。S3 バケットキーの設定にかかわらず、リクエストに `true` または `false` の値の付いた `x-amz-server-side-encryption-bucket-key-enabled` ヘッダーを含めると、バケット設定を上書きできます。
S3 バケットキーを使用するようにバケットを設定する前に、「[S3 バケットキーを有効にする前に注意するべき変更点](#bucket-key-changes)」を確認してください。
### Amazon S3 コンソールを使用した S3 バケットキーの設定
新しいバケットを作成する際、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定できます。また、バケットプロパティを更新して、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するように既存のバケットを設定することもできます。
詳細については、[新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定する](configuring-bucket-key.md) を参照してください。
### S3 バケットキーに対する REST API、AWS CLI、および AWS SDK のサポート
REST API、AWS CLI、または AWS SDK を使用して、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定できます。オブジェクトレベルで S3 バケットキーを有効にすることもできます。
詳細については次を参照してください:
+ [オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)
+ [新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定する](configuring-bucket-key.md)
次の API オペレーションは、SSE−KMS の S3 バケットキーをサポートしています。
+ [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)
+ `ServerSideEncryptionRule` は、S3 バケットキーを有効または無効にする `BucketKeyEnabled` パラメータを受け入れます。
+ [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)
+ `ServerSideEncryptionRule` は の設定を返します。`BucketKeyEnabled`
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)、[CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)、[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)、および [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ `x-amz-server-side-encryption-bucket-key-enabled` リクエストヘッダーは、オブジェクトレベルで S3 バケットキーを有効または無効にします。
+ [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)、[GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)、[UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)、[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)、[CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ `x-amz-server-side-encryption-bucket-key-enabled` レスポンスヘッダーは、オブジェクトに対して S3 バケットキーが有効か無効かを示します。
### CloudFormation の使用
CloudFormation では、`AWS::S3::Bucket` のリソースに S3 バケットキーを有効または無効にするために使用できる `BucketKeyEnabled` と呼ばれる暗号化プロパティが含まれています。
詳細については、[CloudFormation の使用](configuring-bucket-key.md#enable-bucket-key-cloudformation) を参照してください。
## S3 バケットキーを有効にする前に注意するべき変更点
S3 バケットキーを有効にする前に、次の関連する変更点に注意してください。
### IAM または AWS KMS キーポリシー
既存の AWS Identity and Access Management (IAM) ポリシーまたは AWS KMS キーポリシーで、オブジェクトの Amazon リソースネーム (ARN) を暗号化コンテキストとして使用し、KMS キーへのアクセスを絞り込んだり制限したりする場合、S3 バケットキーではこれらのポリシーは機能しません。S3 バケットキーは、バケット ARN を暗号化コンテキストとして使用します。S3 バケットキーを有効にする前に、バケット ARN を暗号化コンテキストとして使用するため、IAM ポリシーまたは AWS KMS キーポリシーを更新してください。
暗号化コンテキストと S3 バケットキーの詳細については、「[暗号化コンテキスト](UsingKMSEncryption.md#encryption-context)」を参照してください。
### AWS KMS の CloudTrail イベント
S3 バケットキーを有効にすると、オブジェクト ARN の代わりに、AWS KMS CloudTrail イベントがバケット ARN をログに記録します。さらに、ログに表示される SSE−KMS オブジェクトの KMS CloudTrail イベントが少なくなります。これは、Amazon S3 ではキーマテリアルに時間制限があり、これにより AWS KMS に対するリクエストが減るためです。
## レプリケーションでの S3 バケットキーの使用
S3 バケットキーは、同一リージョンレプリケーション (SRR) およびクロスリージョンレプリケーション (CRR) で使用できます。
Amazon S3 では、暗号化されたオブジェクトをレプリケートする場合、通常、レプリケート先バケット内のレプリカオブジェクトの暗号化設定が保持されます。ただし、ソースオブジェクトが暗号化されておらず、レプリケート先バケットがデフォルトの暗号化または S3 バケットキーを使用している場合、Amazon S3 はレプリケート先のバケットの設定でオブジェクトを暗号化します。
以下の例では、S3 バケットキーがレプリケーションでどのように機能するかを示しています。詳細については、「[暗号化されたオブジェクトのレプリケート (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)」を参照してください。
**Example 例 1 – ソースオブジェクトで S3 バケットキーを使用し、レプリケート先バケットでデフォルトの暗号化を使用する**
ソースオブジェクトでは S3 バケットキーを使用しているが、レプリケート先バケットでは SSE−KMS によるデフォルトの暗号化を使用している場合、レプリカオブジェクトは S3 バケットキーの暗号化設定をレプリケート先バケットに保持します。レプリケート先バケットでは、SSE−KMS によるデフォルトの暗号化が使用されます。
**Example 例 2 – ソースオブジェクトが暗号化されておらず、レプリケート先バケットで SSE−KMS の S3 バケットキーを使用する**
ソースオブジェクトが暗号化されておらず、レプリケート先のバケットで SSE−KMS の S3 バケットキーを使用する場合、レプリカオブジェクトはレプリケート先バケットで SSE−KMS を使用して、S3 バケットキーで暗号化されます。この結果、ソースオブジェクトの `ETag` はレプリカオブジェクトの `ETag` と異なることになります。この違いに対応するには、`ETag` を使用するアプリケーションを更新する必要があります。
## S3 バケットキーの使用
S3 バケットキーの有効化と使用の詳細については、以下のセクションを参照してください。
+ [新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定する](configuring-bucket-key.md)
+ [オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)
+ [S3 バケットキーの設定の表示](viewing-bucket-key-settings.md)
# 新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定する
AWS Key Management Service (AWS KMS) キー (SSE-KMS) を使用してサーバー側の暗号化を設定する場合、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定できます。S3 バケットキーは、Amazon S3 から AWS KMS へのリクエストトラフィックを減らし、SSE−KMS におけるコストを削減します。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
Amazon S3 コンソール、REST API、AWS SDK、AWS Command Line Interface (AWS CLI)、または CloudFormation を使用して、新しいオブジェクトで SSE−KMS の S3 バケットキーを使用するようにバケットを設定できます。既存のオブジェクトの S3 バケットキーを有効または無効にするには、`CopyObject` オペレーションを使用できます。詳細については、([オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)) および ([バッチオペレーションを使用して SSE-KMS の S3 バケットキーを有効にする](batch-ops-copy-example-bucket-key.md)) を参照してください。
レプリケート元バケットまたはレプリケート先バケットで S3 バケットキーを有効にすると、暗号化コンテキストはバケットの Amazon リソースネーム (ARN) になり、オブジェクト ARN にはなりません (例えば、`arn:aws:s3:::bucket_ARN`)。IAM ポリシーを更新して、暗号化コンテキストにバケット ARN を使用する必要があります。詳細については、「[S3 バケットキーとレプリケーション](replication-config-for-kms-objects.md#bk-replication)」を参照してください。
以下の例では、S3 バケットキーがレプリケーションでどのように機能するかを示しています。詳細については、「[暗号化されたオブジェクトのレプリケート (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)」を参照してください。
**前提条件**
S3 バケットキーを使用するようにバケットを設定する前に、「[S3 バケットキーを有効にする前に注意するべき変更点](bucket-key.md#bucket-key-changes)」を確認してください。
**Topics**
## S3 コンソールの使用
S3 コンソールでは、新しいバケットまたは既存のバケットに対して S3 バケットキーを有効または無効にできます。S3 コンソールのオブジェクトは、バケット設定からそれらの S3 バケットキーの設定を継承します。バケットで S3 バケットキーを有効にすると、バケットにアップロードする新しいオブジェクトでは、SSE-KMS に S3 バケット キーが使用されます。
**S3 バケットキーが有効になっているバケット内のオブジェクトをアップロード、コピー、または変更する**
S3 バケットキーが有効になっているバケットでオブジェクトをアップロード、変更、またはコピーすると、そのオブジェクトの S3 バケットキーの設定がバケット設定に合わせて更新されることがあります。
オブジェクトで既に S3 バケットキーが有効になっている場合、オブジェクトをコピーまたは変更しても、そのオブジェクトの S3 バケットキーの設定は変更されません。ただし、レプリケート先バケットに S3 バケットキーの設定がある状態で S3 バケットキーが有効になっていないオブジェクトを変更またはコピーした場合、オブジェクトはレプリケート先バケットの S3 バケットキーの設定を継承します。例えば、ソースオブジェクトで S3 バケットキーが有効になっていないが、レプリケート先バケットで S3 バケットキーが有効になっている場合、S3 バケットキーは有効になります。
**新しいバケットの作成時に S3 バケットキーを有効にするには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. 左側のナビゲーションペインで、[**バケット**] を選択します。
1. [**Create bucket (バケットの作成)**] を選択します。
1. バケット名を入力し、AWS リージョンを選択します。
1. **[デフォルトの暗号化]** の **[暗号化キーの種類]** で、**[AWS Key Management Service キー (SSE-KMS)]** を選択します。
1. **[AWS KMS キー]** で、次のいずれかを実行して KMS キーを選択します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS** キーを選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
1. **[バケットキー]** で **[有効化]** を選択します。
1. [**Create bucket**] (バケットの作成) をクリックします。
Amazon S3 は、S3 バケットキーを有効にしてバケットを作成します。バケットにアップロードする新しいオブジェクトには、S3 バケットキーを使用します。
S3 バケットキーを無効にするには、前の手順に従い、**[無効化]** を選択します。
**既存のバケットに対して S3 バケットキーを有効にするには**
1. Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **[バケット]** リストで、S3 バケットキーを有効にするバケットを選択します。
1. **[プロパティ]** タブを選択します。
1. **[デフォルトの暗号化]** で、**[編集]** を選択します。
1. **[デフォルトの暗号化]** の **[暗号化キーの種類]** で、**[AWS Key Management Service キー (SSE-KMS)]** を選択します。
1. **[AWS KMS キー]** で、次のいずれかを実行して KMS キーを選択します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS** キーを選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
1. **[バケットキー]** で **[有効化]** を選択します。
1. [**Save changes**] (変更を保存) をクリックします。
Amazon S3 では、バケットに追加された新しいオブジェクトに対して S3 バケットキーが有効になります。既存のオブジェクトでは S3 バケットキーは使用しません。既存のオブジェクトの S3 バケットキーを設定するには、`CopyObject` オペレーションを使用できます。詳細については、「[オブジェクトレベルで S3 バケットキーを設定する](configuring-bucket-key-object.md)」を参照してください。
S3 バケットキーを無効にするには、前の手順に従い、[**Disable (無効化)**] を選択します。
## REST API の使用
[PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) を使用してバケットの S3 バケットキーを有効または無効にできます。`PutBucketEncryption` で S3 バケットキーを設定するには、[ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html) を使用します。これには、SSE-KMS を使用したデフォルトの暗号化が含まれます。また、オプションで、カスタマーマネージドキーの KMS キー ID を指定して、カスタマーマネージドキーを使用することもできます。
詳細と構文の例については、[PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) を参照してください。
## AWS SDK for Java の使用
次の例では、AWS SDK for Java を使用して、S3 バケットキーと SSE−KMS によるデフォルトのバケット暗号化を有効にします。
------
#### [ Java ]
```
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.DEFAULT_REGION)
.build();
ServerSideEncryptionByDefault serverSideEncryptionByDefault = new ServerSideEncryptionByDefault()
.withSSEAlgorithm(SSEAlgorithm.KMS);
ServerSideEncryptionRule rule = new ServerSideEncryptionRule()
.withApplyServerSideEncryptionByDefault(serverSideEncryptionByDefault)
.withBucketKeyEnabled(true);
ServerSideEncryptionConfiguration serverSideEncryptionConfiguration =
new ServerSideEncryptionConfiguration().withRules(Collections.singleton(rule));
SetBucketEncryptionRequest setBucketEncryptionRequest = new SetBucketEncryptionRequest()
.withServerSideEncryptionConfiguration(serverSideEncryptionConfiguration)
.withBucketName(bucketName);
s3client.setBucketEncryption(setBucketEncryptionRequest);
```
------
## の使用AWS CLI
次の例では、AWS CLI を使用して、S3 バケットキーと SSE−KMS によるデフォルトのバケット暗号化を有効にします。`user input placeholders` を、ユーザー自身の情報に置き換えます。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "aws:kms",
"KMSMasterKeyID": "KMS-Key-ARN"
},
"BucketKeyEnabled": true
}
]
}'
```
## CloudFormation の使用
CloudFormation を使用して S3 バケットキーを設定する方法の詳細については、*AWS CloudFormation ユーザーガイド*の「[AWS::S3::Bucket ServerSideEncryptionRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html)」を参照してください。
# オブジェクトレベルで S3 バケットキーを設定する
REST API、AWS SDK、または AWS CLI を使用して PUT オペレーションまたは COPY オペレーションを実行する際、`true` または `false` の値の付いた `x-amz-server-side-encryption-bucket-key-enabled` リスエストヘッダーを追加して、オブジェクトレベルで S3 バケットキーを有効または無効にできます。S3 バケットキーは、Amazon S3 から AWS KMS へのリクエストトラフィックを減らすことにより、AWS Key Management Service (AWS KMS) (SSE−KMS) を使用したサーバー側の暗号化のコストを削減します。詳細については、[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md) を参照してください。
PUT オペレーションまたは COPY オペレーションを使用してオブジェクトの S3 バケットキーを設定すると、Amazon S3 では、そのオブジェクトの設定のみが更新されます。レプリケート先バケットの S3 バケットキーの設定は変更されません。KMS で暗号化されたオブジェクトの PUT または COPY リクエストを S3 バケットキーが有効になっているバケットに送信すると、リクエストヘッダーのキーを無効にしない限り、オブジェクトレベルのオペレーションでは自動的に S3 バケットキーが使用されます。オブジェクトに S3 バケットキーを指定しない場合、Amazon S3 ではレプリケート先バケットの S3 バケットキーの設定がオブジェクトに適用されます。
**前提条件:**
S3 バケットキーを使用するようにオブジェクトを設定する前に、「[S3 バケットキーを有効にする前に注意するべき変更点](bucket-key.md#bucket-key-changes)」を確認してください。
**Topics**
+ [
## Amazon S3 バッチオペレーション
](#bucket-key-object-bops)
+ [
## REST API の使用
](#bucket-key-object-rest)
+ [
## AWS SDK Java (PutObject) の使用
](#bucket-key-object-sdk)
+ [
## AWS CLI (PutObject) の使用
](#bucket-key-object-cli)
## Amazon S3 バッチオペレーション
既存の Amazon S3 オブジェクトを暗号化するには、Amazon S3 バッチオペレーションを使用します。S3 バッチオペレーションは、操作するオブジェクトのリストとともに提供します。バッチオペレーションは各 API を呼び出して、指定されたオペレーションを実行します。
[S3 バッチオペレーションのコピーオペレーション](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-copy-object.html)を使用して、既存の暗号化されていないオブジェクトをコピーし、同じバケットに新しい暗号化されたオブジェクトを書き込めます。1 つのバッチオペレーションジョブで、数十億ものオブジェクトに対して、指定されたオペレーションを実行できます。詳細については、[バッチオペレーションでオブジェクトオペレーションを一括で実行する](batch-ops.md) および [Amazon S3 バッチオペレーションによるオブジェクトの暗号化](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)を参照してください。
## REST API の使用
SSE−KMS を使用すると、次の API を使用して、オブジェクトの S3 バケットキーを有効にできます。
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) – オブジェクトをアップロードするときに、`x-amz-server-side-encryption-bucket-key-enabled` リクエストヘッダーを指定して、オブジェクトレベルで S3 バケットキーを有効または無効にできます。
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) – オブジェクトをコピーして SSE−KMS を設定するときに、`x-amz-server-side-encryption-bucket-key-enabled` リクエストヘッダーを指定して、オブジェクトの S3 バケットキーを有効または無効にできます。
+ [PostObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) – `POST` オペレーションを使用してオブジェクトをアップロードし、SSE−KMS を設定するとき、`x-amz-server-side-encryption-bucket-key-enabled` フォームフィールドを使用してオブジェクトの S3 バケットキーを有効または無効にできます。
+ [CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) – `CreateMultipartUpload` API オペレーションを使用して大きなオブジェクトをアップロードし、SSE−KMS を設定する場合、`x-amz-server-side-encryption-bucket-key-enabled` リクエストヘッダーを使用してオブジェクトの S3 バケットキーを有効または無効にできます。
オブジェクトレベルで S3 バケットキーを有効にするには、`x-amz-server-side-encryption-bucket-key-enabled` リクエストヘッダーを含めます。SSE−KMS および REST API の詳細については、[REST API の使用](specifying-kms-encryption.md#KMSUsingRESTAPI) を参照してください。
## AWS SDK Java (PutObject) の使用
次の例を使用して、AWS SDK for Java を使ってオブジェクトレベルで S3 バケットキーを設定できます。
------
#### [ Java ]
```
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.DEFAULT_REGION)
.build();
String bucketName = "amzn-s3-demo-bucket1";
String keyName = "key name for object";
String contents = "file contents";
PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, keyName, contents)
.withBucketKeyEnabled(true);
s3client.putObject(putObjectRequest);
```
------
## AWS CLI (PutObject) の使用
次の AWS CLI の例を使用して、`PutObject` リクエストの一部としてオブジェクトレベルで S3 バケットキーを設定できます。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key object key name --server-side-encryption aws:kms --bucket-key-enabled --body filepath
```
# S3 バケットキーの設定の表示
Amazon S3 コンソール、REST API、AWS Command Line Interface (AWS CLI)、または AWS SDK を使用して、バケットまたはオブジェクトレベルで S3 バケットキーの設定を表示できます。
S3 バケットキーは、Amazon S3 から AWS KMS へのリクエストトラフィックを減らし、AWS Key Management Service (SSE−KMS) を使用したサーバー側の暗号化のコストを削減します。詳細については、「[Amazon S3 バケットキーを使用した SSE−KMS のコストの削減](bucket-key.md)」を参照してください。
バケット設定から S3 バケット キー設定を継承したバケットまたはオブジェクトの S3 バケット キー設定を表示するには、`s3:GetEncryptionConfiguration` アクションを実行するアクセス許可が必要です。詳細については、*Amazon Simple Storage Service API リファレンス*の [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html) を参照してください。
## S3 コンソールの使用
S3 コンソールでは、バケットまたはオブジェクトの S3 バケットキーの設定を表示できます。ソースオブジェクトにすでに S3 バケットキーが設定されていない限り、S3 バケットキーの設定はバケット設定から継承されます。
同じバケット内のオブジェクトとフォルダは、異なる S3 バケットキーの設定を行えます。例えば、REST API を使用してオブジェクトをアップロードし、そのオブジェクトの S3 バケットキーを有効にした場合、レプリケート先バケットで S3 バケットキーが無効になっている場合でも、S3 バケットキーの設定は保持されます。別の例として、既存のバケットに対して S3 バケットキーを有効にした場合、バケット内に既に存在するオブジェクトには S3 バケットキーを使用できません。ただし、新しいオブジェクトでは S3 バケットキーが有効になります。
**バケットの S3 バケットキーの設定を表示するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) を開きます。
1. 左側のナビゲーションペインで、**[バケット]** を選択します。
1. **[バケット]** リストで、S3 バケットキーを有効にするバケットを選択します。
1. [**プロパティ**] を選択します。
1. [**Default encryption (デフォルトの暗号化)**] セクションの [**バケットキー**] に、バケットの S3 バケットキーの設定が表示されます。
S3 バケットキーの設定が表示されない場合は、`s3:GetEncryptionConfiguration` アクションを実行するアクセス許可がない可能性があります。詳細については、**「Amazon Simple Storage Service API リファレンス」の「[GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)」を参照してください。
**オブジェクトの S3 バケットキーの設定を表示するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. [**バケット**] リストで、S3 バケットキーを有効にするバケットを選択します。
1. [**オブジェクト**] リストで、オブジェクト名を選択します。
1. [**詳細**] タブの [**Server−side encryption settings (サーバー側の暗号化設定)**] で、[**Edit (編集)**] を選択します。
**[バケットキー]** の下に、オブジェクトの S3 バケットキーの設定が表示されます。この設定を編集することはできません。
## の使用AWS CLI
**バケットレベルの S3 バケットキーの設定を返すには**
この例を実行するには、それぞれの `user input placeholder` をユーザー自身の情報に置き換えます。
```
aws s3api get-bucket-encryption --bucket amzn-s3-demo-bucket1
```
詳細については、「*AWS CLI コマンドリファレンス*」の「[get-bucket-encryption](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-bucket-encryption.html)」を参照してください。
**S3 バケットキーのオブジェクトレベルの設定を返すには**
この例を実行するには、それぞれの `user input placeholder` をユーザー自身の情報に置き換えます。
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key my_images.tar.bz2
```
詳細については、「*AWS CLI コマンドリファレンス*」の「[head-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html)」を参照してください。
## REST API の使用
**バケットレベルの S3 バケットキーの設定を返すには**
S3 バケットキーの設定を含むバケットの暗号化情報を返すには、`GetBucketEncryption` オペレーションを使用します。S3 バケットキーの設定は、`BucketKeyEnabled` の設定と共に `ServerSideEncryptionConfiguration` 要素のレスポンス本文に返されます。詳細については、[Amazon S3 API リファレンス](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)の *GetBucketEncryption* を参照してください。
**S3 バケットキーのオブジェクトレベルの設定を返すには**
オブジェクトの S3 バケットキーのステータスを返すには、`HeadObject` オペレーションを使用します。`HeadObject` は、オブジェクトに対して S3 バケットキーが有効か無効かを示す `x-amz-server-side-encryption-bucket-key-enabled` レスポンスヘッダーを返します。詳細については、[Amazon S3 API リファレンス](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html) の *HeadObject* を参照してください。
次の API オペレーションは、オブジェクトに対して S3 バケットキーが設定されている場合、`x-amz-server-side-encryption-bucket-key-enabled` レスポンスヘッダーも返します。
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [PostObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
# AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の使用
AWS Key Management Service (AWS KMS) キーによる二層式サーバー側の暗号化 (DSSE-KMS) を使用すると、オブジェクトが Amazon S3 にアップロードされるときに 2 つの暗号化レイヤーが適用されます。DSSE-KMS を使用すると、データに多層暗号化を適用し、暗号化キーを完全に制御する必要があるコンプライアンス基準をより簡単に満たすことができます。
DSSE-KMS の「デュアル」とは、データに適用される 2 つの独立した AES-256 暗号化レイヤーを指します。
+ *1 番目のレイヤー:* データは、AWS KMS によって生成された一意のデータ暗号化キー (DEK) を使用して暗号化されます。
+ *2 番目のレイヤー:* 既に暗号化されたデータは、Amazon S3 によって管理される別の AES-256 暗号化キーを使用して再度暗号化されます。
これは、単一の暗号化レイヤーのみを適用する標準の SSE-KMS とは異なります。デュアルレイヤーアプローチは、1 番目の暗号化レイヤーが侵害された場合でも、データが 2 番目のレイヤーによって保護され続けるようにすることで、セキュリティを強化します。この追加のセキュリティでは、処理オーバーヘッドと AWS KMS API コールが増加し、標準 SSE-KMS と比較してコストが高くなります。DSSE-KMS 料金の詳細については、「AWS Key Management Service デベロッパーガイド」の「[AWS KMS key concepts](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys)」と「[AWS KMS の料金](https://aws.amazon.com/kms/pricing)」を参照してください。
S3 バケットで DSSE−KMS を使用する場合、AWS KMS キーはバケットと同じリージョンに存在する必要があります。また、オブジェクトに対して DSSE-KMS がリクエストされると、オブジェクトのメタデータの一部である S3 チェックサムが暗号化された形式で保存されます。チェックサムの詳細については、「[Amazon S3 でのオブジェクトの整合性のチェック](checking-object-integrity.md)」を参照してください。
**注記**
S3 バケットキーは DSSE-KMS ではサポートされていません。
DSSE-KMS と標準 SSE-KMS の主な違いは次のとおりです。
+ **暗号化レイヤー:** DSSE-KMS は 2 つの独立した AES-256 暗号化レイヤーを適用し、標準の SSE-KMS は 1 つのレイヤーを適用します。
+ **セキュリティ:** DSSE-KMS は暗号化の潜在的な脆弱性に対する保護を強化します
+ **コンプライアンス:** DSSE-KMS は、多層暗号化を義務付ける規制要件を満たすのに役立ちます
+ **パフォーマンス:** DSSE-KMS は追加の暗号化処理によりレイテンシーがわずかに増加します
+ **コスト:** DSSE-KMS では、計算オーバーヘッドの増加と AWS KMS オペレーションの追加により、より高い料金が発生します
**AWS KMS keys キーによる二層式サーバー側の暗号化 (DSSE-KMS) の要求**
特定の Amazon S3 バケット内のすべてのオブジェクトの二層式サーバー側の暗号化を要求するには、バケットポリシーを使用できます。例えば、DSSE-KMS を使用したサーバー側の暗号化を要求する `x-amz-server-side-encryption` ヘッダーがリクエストに含まれていない場合、次のバケットポリシーはすべてのユーザーに対し、オブジェクト (`s3:PutObject`) をアップロードするアクセス許可を拒否します。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [{
"Sid": "DenyUnEncryptedObjectUploads",
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "aws:kms:dsse"
}
}
}
]
}
```
------
**Topics**
+ [
# AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の指定
](specifying-dsse-encryption.md)
# AWS KMS キーによる二層式サーバー側の暗号化 (DSSE-KMS) の指定
暗号化は、新しいオブジェクトをアップロードしたり、既存のオブジェクトをコピーしたりするときに適用できます。
Amazon S3 コンソール、Amazon S3 REST API、および AWS Command Line Interface (AWS CLI) を使用して、DSSE-KMS を指定できます。詳細については、以下のトピックを参照してください。
**注記**
Amazon S3 では、マルチリージョン AWS KMS keys を使用できます。ただし、Amazon S3 では現在、マルチリージョンキーは、単一リージョンキーであるかのように処理され、キーのマルチリージョン特徴は使用しません。詳細については、「AWS Key Management Service デベロッパーガイド」の「[Using multi-Region keys](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)」を参照してください。**
**注記**
別のアカウントが所有している KMS キーを使用する場合は、そのキーを使用するアクセス許可が必要です。KMS キーのクロスアカウント権限の詳細については、*AWS Key Management Service デベロッパーガイド*の「[他のアカウントで使用できる KMS キーを作成する](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)」を参照してください。
## S3 コンソールの使用
このセクションでは、Amazon S3 コンソールを使用して、AWS Key Management Service (AWS KMS) キーによる二層式サーバー側の暗号化 (DSSE-KMS) を使用するようにオブジェクトの暗号化のタイプを設定または変更する方法について説明します。
**注記**
オブジェクトが 5 GB 未満の場合は、オブジェクトの暗号化を変更できます。オブジェクトが 5 GB を超える場合は、[AWS CLI](mpu-upload-object.md#UsingCLImpUpload) または [AWS SDK](CopyingObjectsMPUapi.md) を使用してオブジェクトの暗号化を変更する必要があります。
オブジェクトの暗号化の変更に必要な追加のアクセス許可のリストについては、「[Amazon S3 API オペレーションに必要なアクセス許可](using-with-s3-policy-actions.md)」を参照してください。このアクセス許可を付与するポリシーの例については、「[Amazon S3 のアイデンティティベースのポリシー例](example-policies-s3.md)」を参照してください。
オブジェクトの暗号化を変更すると、新しいオブジェクトが作成され、古いオブジェクトが置き換えられます。S3 バージョニングが有効になっている場合は、オブジェクトの新しいバージョンが作成され、既存のオブジェクトが古いバージョンになります。また、プロパティを変更するロールは、新しいオブジェクト (またはオブジェクトのバージョン) の所有者になります。
**オブジェクトの暗号化を追加または変更するには**
1. AWS マネジメントコンソール にサインインし、Amazon S3 コンソール ([https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)) を開きます。
1. ナビゲーションペインで **[バケット]** を選択してから、**[汎用バケット]** タブをクリックします。変更するオブジェクトを含む Amazon S3 バケットまたはフォルダに移動します。
1. 変更するオブジェクトのチェックボックスをオンにします。
1. **[アクション]** メニューに表示されるオプションのリストから **[サーバー側の暗号化を編集]** を選択します。
1. **[サーバー側の暗号化]** セクションまでスクロールします。
1. **[暗号化設定]** で、**[デフォルトの暗号化にバケット設定を使用する]** または **[デフォルトの暗号化にバケット設定を上書きする]** を選択します。
1. **[デフォルトの暗号化にバケット設定を上書きする]** を選択した場合は、次の暗号化設定を設定します。
1. **[暗号化タイプ]** で、**[AWS Key Management Service キーによる二層式サーバー側の暗号化 (DSSE-KMS)]** を選択します。
1. **[AWS KMS キー]** で、次のいずれかを実行して KMS キーを選択します。
+ 使用可能な KMS キーのリストから選択するには、**[AWS KMS keys から選択する]** を選択し、使用可能なキーのリストから自分の **KMS** キーを選択します。
AWS マネージドキー (`aws/s3`) とカスタマーマネージドキーの両方がこのリストに表示されます。カスタマーマネージドキーの詳細については、*AWS Key Management Serviceデベロッパーガイド*の「[カスタマーキーと AWS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)」を参照してください。
+ KMS キー ARN を入力するには、**[AWS KMS key ARN を入力]** を選択し、表示されるフィールドに KMS キー ARN を入力します。
+ AWS KMS コンソールで新しいカスタマーマネージドキーを作成するには、**[KMS キーを作成]** を選択します。
AWS KMS key の作成の詳細については、**「AWS Key Management Service デベロッパーガイド」の「[キーの作成](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)」を参照してください。
**重要**
バケットと同じ AWS リージョン で使用可能な KMS キーのみを使用できます。Amazon S3 コンソールには、バケットと同じリージョンで最初の 100 個の KMS キーしか表示されません。リストに存在しない KMS キーを使用するには、KMS キー ARN を入力する必要があります。別のアカウントが所有している KMS キーを使用する場合は、まず、そのキーを使用するアクセス許可が必要であり、次に、KMS キー ARN を入力する必要があります。
Amazon S3 では、対称暗号化 KMS キーのみがサポートされ、非対称暗号化 KMS キーはサポートされません。詳細については、『*AWS Key Management Service デベロッパーガイド*』の「[非対称 KMS キーの識別](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html)」を参照してください。
1. **[バケットキー]** で、**[無効]** を選択します。S3 バケットキーは DSSE-KMS ではサポートされていません。
1. **[追加のコピー設定]** で、**[ソース設定をコピー]** するか、**[設定を指定しない]** か、**[設定を指定]** するかを選択します。**[ソース設定をコピー]** がデフォルトのオプションです。ソース設定の属性なしでオブジェクトのみをコピーする場合は、**[設定を指定しない]** を選択します。ストレージクラス、ACL、オブジェクトタグ、メタデータ、サーバー側の暗号化、その他のチェックサムの設定を指定するには、**[設定を指定]** を選択します。
1. **[Save changes]** (変更の保存) をクリックします。
**注記**
このアクションは、指定されたすべてのオブジェクトに暗号化を適用します。フォルダを暗号化する場合は、保存オペレーションが完了するのを待ってから、フォルダに新しいオブジェクトを追加します。
## REST API の使用
オブジェクトを作成するとき (新しいオブジェクトをアップロードするか、既存のオブジェクトをコピーするとき) に、AWS KMS keys による二層式サーバー側の暗号化 (DSSE-KMS) の使用を指定してデータを暗号化できます。これを行うには、リクエストに `x-amz-server-side-encryption` ヘッダーを追加します。ヘッダーの値を、暗号化アルゴリズム `aws:kms:dsse` に設定します。Amazon S3 によりレスポンスヘッダー `x-amz-server-side-encryption` が返されるため、DSSE-KMS 暗号化を使用してオブジェクトが保存されたことを確認できます。
`x-amz-server-side-encryption` の値で `aws:kms:dsse` ヘッダーを指定する場合は、次のリクエストヘッダーも使用できます。
+ `x-amz-server-side-encryption-aws-kms-key-id: SSEKMSKeyId`
+ `x-amz-server-side-encryption-context: SSEKMSEncryptionContext`
**Topics**
+ [
### DSSE-KMS をサポートする Amazon S3 REST API オペレーション
](#dsse-request-headers-kms)
+ [
### 暗号化コンテキスト (`x-amz-server-side-encryption-context`)
](#s3-dsse-encryption-context)
+ [
### AWS KMS キー ID (`x-amz-server-side-encryption-aws-kms-key-id`)
](#s3-dsse-key-id-api)
### DSSE-KMS をサポートする Amazon S3 REST API オペレーション
次の REST API オペレーションでは `x-amz-server-side-encryption`、`x-amz-server-side-encryption-aws-kms-key-id`、および `x-amz-server-side-encryption-context` リクエストヘッダーを受け入れます。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) - `PUT` オペレーションを使用してデータをアップロードするとき、これらのリクエストヘッダーを指定できます。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) — オブジェクトをコピーするときには、ソースオブジェクトとターゲットオブジェクトの両方があります。`CopyObject` オペレーションで DSSE−KMS ヘッダーを渡すと、ターゲットオブジェクトにのみ適用されます。既存のオブジェクトをコピーする際は、コピー元オブジェクトが暗号化されているかどうかに関係なく、明示的にサーバー側の暗号化を要求しない限り、コピー先オブジェクトは暗号化されません。
+ [POST オブジェクト](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) — `POST` オペレーションを使用してオブジェクトをアップロードするときには、リクエストヘッダーの代わりに、フォームフィールドで同じ情報を指定します。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) - マルチパートアップロードを使用して大きいオブジェクトをアップロードするときには、`CreateMultipartUpload` リクエストでこれらのヘッダーを指定できます。
次の REST API オペレーションのレスポンスヘッダーは、オブジェクトがサーバー側の暗号化を使用して保存されるときに `x-amz-server-side-encryption` ヘッダーを返します。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [POST オブジェクト](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)
**重要**
AWS KMS で保護されたオブジェクトに対する `GET` および `PUT` リクエストはすべて、Secure Sockets Layer (SSL)、Transport Layer Security (TLS)、または署名バージョン 4 を使用していない場合、失敗します。
オブジェクトで DSSE−KMS を使用している場合、`GET` リクエストおよび `HEAD` リクエストの暗号化リクエストヘッダーを送信しないでください。送信すると、HTTP 400 (Bad Request) エラーが発生します。
### 暗号化コンテキスト (`x-amz-server-side-encryption-context`)
`x-amz-server-side-encryption:aws:kms:dsse` を指定した場合、Amazon S3 API は `x-amz-server-side-encryption-context` ヘッダーの暗号化コンテキストをサポートします。暗号化コンテキストは、データに関する追加のコンテキスト情報が含まれたキーバリューペアのセットです。
Amazon S3 は、オブジェクトの Amazon リソースネーム (ARN) を暗号化コンテキストペア (`arn:aws:s3:::object_ARN` など) として自動的に使用します。
オプションで、`x-amz-server-side-encryption-context` ヘッダーを使用して、追加の暗号化コンテキストペアを指定することもできます。しかし、暗号化コンテキストは暗号化されないため、機密情報を含めないでください。Amazon S3 は、この追加のキーペアをデフォルトの暗号化コンテキストとともに保存します。
Amazon S3 の暗号化コンテキストの詳細については、「[暗号化コンテキスト](UsingKMSEncryption.md#encryption-context)」を参照してください。暗号化コンテキストの一般的な情報については、**「AWS Key Management Service デベロッパーガイド」の「[AWS Key Management Service Concepts - Encryption context](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)」を参照してください。
### AWS KMS キー ID (`x-amz-server-side-encryption-aws-kms-key-id`)
`x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを使用して、データの保護に使用するカスタマーマネージドキーの ID を指定できます。`x-amz-server-side-encryption:aws:kms:dsse` ヘッダーを指定しても `x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを指定しない場合、Amazon S3 は AWS マネージドキー (`aws/s3`) を使用してデータを保護します。カスタマーマネージドキーを使用する場合は、カスタマーマネージドキーの `x-amz-server-side-encryption-aws-kms-key-id` ヘッダーを指定する必要があります。
**重要**
Amazon S3 でサーバー側の暗号化に AWS KMS key を使用する場合は、対称暗号化 KMS キーを選択する必要があります。Amazon S3 は、対称暗号化 KMS キーのみをサポートします。このキーの詳細については、「**AWS Key Management Service デベロッパーガイド」の「[対称暗号化 KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)」を参照してください。
## の使用AWS CLI
新しいオブジェクトをアップロードするか、既存のオブジェクトをコピーするときに、 データの暗号に DSSE-KMS を使用することを指定できます。これを行うには、リクエストに `--server-side-encryption aws:kms:dsse` パラメータを追加します。`--ssekms-key-id example-key-id` パラメータを使用して、作成した[カスタマーマネージド AWS KMS キー](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#customer-cmk)を追加します。AWS KMS キー ID を指定せずに `--server-side-encryption aws:kms:dsse` を指定した場合、Amazon S3 は AWS マネージドキー (`aws/s3`) を使用します。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms:dsse --ssekms-key-id example-key-id --body filepath
```
暗号化されていないオブジェクトを元の場所にコピーすることで、DSSE-KMS を使用するように暗号化できます。
```
aws s3api copy-object --bucket amzn-s3-demo-bucket --key example-object-key --copy-source amzn-s3-demo-bucket/example-object-key --server-side-encryption aws:kms:dsse --ssekms-key-id example-key-id
```
# お客様が指定したキーによるサーバー側の暗号化 (SSE−C) の使用
サーバー側の暗号化は、保管時のデータ保護に関するものです。サーバー側の暗号化では、オブジェクトのメタデータではなく、オブジェクトデータのみが暗号化されます。汎用バケットでお客様が用意したキーでのサーバー側の暗号化 (SSE−C) を使用すると、独自の暗号化キーでデータを暗号化できます。リクエストの一部として用意された暗号化キーで、Amazon S3 は、ディスクに書き込む際のデータ暗号化と、オブジェクトにアクセスする際のデータ復号を管理します。したがって、データの暗号化と復号を実行するコードをお客様が管理する必要はありません。必要なことは、お客様が用意する暗号化キーを管理することだけです。
Amazon S3 の最新のユースケースのほとんどでは、Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) や AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の柔軟性が欠けているため、SSE-C は使用されなくなりました。SSE-C では、SSE-C 暗号化データとやり取りするたびに暗号化キーを提供する必要があるため、S3 バケットからデータを読み取ってデータを操作しようとする他のユーザー、ロール、または AWS のサービスと SSE-C キーを共有することは実用的ではありません。AWS 全体で SSE-KMS が広範囲にサポートされているため、ほとんどの最新のワークロードでは SSE-KMS の柔軟性が不足しているため、SSE-C 暗号化を使用しません。SSE-KMS の詳細については、「[AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の使用](UsingKMSEncryption.md)」を参照してください。
バケットに書き込まれたオブジェクトに SSE-C 暗号化が使用されないようにするには、バケットのデフォルトの暗号化設定を変更するときに SSE-C 暗号化をブロックできます。汎用バケットに対して SSE-C がブロックされている場合、SSE-C 暗号化を指定する `PutObject`、`CopyObject`、`PostObject`、マルチパートアップロードまたはレプリケーションリクエストは `HTTP 403 AccessDenied` エラーで拒否されます。SSE-C のブロックの詳細については、「[汎用バケットの SSE-C のブロックまたはブロック解除](blocking-unblocking-s3-c-encryption-gpb.md)」を参照してください。
SSE-C の使用に追加料金はかかりません。ただし、SSE-C を設定および使用するためのリクエストには、標準の Amazon S3 リクエスト料金が発生します。料金については、「[Amazon S3 の料金](https://aws.amazon.com/s3/pricing/)」を参照してください。
**重要**
2026 年 4 月以降、AWS はすべての新しいバケットについて、お客様が用意したキー (SSE-C) によるサーバー側の暗号化を無効にします。さらに、SSE-C 暗号化は、SSE-C 暗号化データを持たない AWS アカウントのすべての既存のバケットに対して無効になります。これらの変更により、SSE-C 暗号化を必要とする少数のアプリケーションは、バケットの作成後に [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API を介して SSE-C の使用を意図的に有効にする必要があります。このような場合、自動化スクリプト、CloudFormation テンプレート、またはその他のインフラストラクチャ設定ツールを更新して、これらの設定を構成する必要がある場合があります。詳細については、[AWS ストレージブログ記事](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/)を参照してください。
## SSE-C を使用する前の考慮事項
+ S3 は暗号化キーを保存しません。S3 から SSE-C 暗号化データをダウンロードするたびに、暗号化キーを指定する必要があります。
+ 使用した暗号化キーと暗号化したオブジェクトのマッピングは、お客様に管理していただきます。どのオブジェクトにどの暗号化キーを使用したかは、お客様が管理してください。これは、暗号化キーを紛失した場合、オブジェクトも失われることを意味します。
+ クライアント側の暗号化キーはお客様が管理するため、キーの更新など、クライアント側での追加の安全対策はお客様に管理していただきます。
+ この設計により、データを操作する他のユーザー、ロール、または AWS のサービスと SSE-C キーを共有することが困難になる可能性があります。AWS 全体で SSE-KMS が広範囲にサポートされているため、ほとんどの最新のワークロードでは SSE-KMS の柔軟性が不足しているため、SSE-C を使用しません。SSE-KMS の詳細については、「[AWS KMS キーによるサーバー側の暗号化の使用 (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)」を参照してください。
+ つまり、SSE-C で暗号化されたオブジェクトは、AWS マネージドサービスによってネイティブに復号することはできません。
+ リクエストで SSE-C ヘッダーを指定するときは、HTTPS を使用する必要があります。
+ SSE−C を使用する場合、Amazon S3 は HTTP 経由で行われたリクエストをすべて拒否します。セキュリティ上の考慮事項として、誤って HTTP で送信されたキーは漏洩したと見なすことをお勧めします。キーを破棄して、必要に応じて更新してください。
+ バケットのバージョニングが有効になっている場合、アップロードする各オブジェクトバージョンに、独自の暗号化キーを使用できます。どのオブジェクトバージョンにどの暗号化キーを使用したかは、お客様が管理してください。
+ SSE-C は Amazon S3 コンソールではサポートされていません。Amazon S3 コンソールを使用してオブジェクトをアップロードし、SSE-C 暗号化を指定することはできません。また、コンソールを使用して、SSE-C を使用して保存されている既存のオブジェクトを更新すること (ストレージクラスの変更やメタデータの追加など) もできません。
**Topics**
+ [
## SSE-C を使用する前の考慮事項
](#considerations-before-using-sse-c)
+ [
# お客様が用意したキーによるサーバー側の暗号化 (SSE−C) の指定
](specifying-s3-c-encryption.md)
+ [
# 汎用バケットの SSE-C のブロックまたはブロック解除
](blocking-unblocking-s3-c-encryption-gpb.md)
+ [
# 新しいバケットの SSE-C 設定に関するよくある質問
](default-s3-c-encryption-setting-faq.md)
# お客様が用意したキーによるサーバー側の暗号化 (SSE−C) の指定
お客様が用意したキーによるサーバー側の暗号化 (SSE-C) を使用するには、まず SSE-C が Amazon S3 汎用バケットのデフォルトの暗号化設定でブロックされた暗号化タイプではないことを確認してください。ブロックされている場合は、バケットのデフォルトの暗号化設定を更新することで、この暗号化タイプを有効にできます。次に、必要なヘッダーを渡すことで、アップロードリクエストで SSE-C を使用できます。「[SSE-C を使用したデータの書き込みをサポートする Amazon S3 アクション](#amazon-s3-actions-that-support-writing-data-with-sse-c)」を参照し、必ず [SSE-C オブジェクトの暗号化および復号リクエストに必要な S3 API ヘッダー](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests) を含めてください。
SSE-C を指定してオブジェクトをアップロードする場合、Amazon S3 はお客様が用意した暗号化キーを使用してデータに AES−256 暗号化を適用します。その後、Amazon S3 はメモリから暗号化キーを削除します。オブジェクトを取得するときは、リクエストの中で同じ暗号化キーを指定する必要があります。Amazon S3 では、最初に指定された暗号化キーが一致することを確認した後、オブジェクトを復号してから、オブジェクトデータを返します。
SSE-C を使用する前に、「[SSE-C を使用する前の考慮事項](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c)」を確認してください。
**注記**
Amazon S3 では、お客様が用意した暗号化キーを保存しません。代わりに、以降のリクエストを検証するために、ランダムな SALT 値が付加された暗号化キーの Hash-based Message Authentication Code (HMAC) 値が保存されます。SALT 値が付加された HMAC 値を使用して、暗号化キーの値を求めたり、暗号化されたオブジェクトの内容を復号したりすることはできません。これは、暗号化キーを紛失した場合、オブジェクトが失われることを意味します。
**Topics**
+ [
## SSE-C アクションと必要なヘッダー
](#sse-c-actions-and-required-headers)
+ [
## SSE-C 暗号化を適用するためのバケットポリシーの例
](#example-bucket-policy-to-enforce-sse-c-encryption)
+ [
## 署名済み URL および SSE−C
](#ssec-and-presignedurl)
+ [
## SSE-C によるリクエストの作成
](#making-requests-with-sse-c)
+ [
## REST API の使用
](#using-rest-api-sse-c)
+ [
## AWS SDK を使用して PUT、GET、Head、および Copy オペレーションの SSE−C を指定する
](#sse-c-using-sdks)
+ [
## AWS SDK を使用してマルチパートアップロードの SSE−C を指定する
](#sse-c-using-sdks-multipart-uploads)
## SSE-C アクションと必要なヘッダー
サポートされている S3 API で SSE-C を指定するには、特定のリクエストパラメータを渡す必要があります。
**注記**
Amazon S3 の `PutBucketEncryption` API は、バケットのデフォルトのサーバー側の暗号化を設定するために使用されます。ただし、`PutBucketEncryption` はバケットのデフォルトの暗号化方法としての SSE-C の有効化をサポートしていません。SSE-C はオブジェクトレベルの暗号化方法で、オブジェクトのアップロードまたはダウンロードリクエストごとに暗号化キーを Amazon S3 に提供します。Amazon S3 はこのキーを使用して、リクエスト中にオブジェクトを暗号化または復号し、キーを破棄します。つまり、SSE-C はデフォルトのバケット設定としてではなく、オブジェクトごとに有効になります。
### SSE-C を使用したデータの書き込みをサポートする Amazon S3 アクション
次の API オペレーションまたはアクションを使用して、汎用バケットにオブジェクトを書き込むときに、お客様が用意したキー (SSE-C) によるサーバー側の暗号化をリクエストできます。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
**注記**
S3 レプリケーションは、SSE-C で暗号化されたオブジェクトをサポートします。暗号化されたオブジェクトのレプリケーションの詳細については、「[暗号化されたオブジェクトのレプリケート (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)」を参照してください。
### SSE-C オブジェクトの暗号化および復号リクエストに必要な S3 API ヘッダー
SSE-C でオブジェクトを暗号化または復号するには、次の 3 つの API ヘッダーを指定する必要があります。
+ `x-amz-server-side-encryption-customer-algorithm` 暗号化アルゴリズムを指定するには、このヘッダーを使用します。ヘッダーの値は AES256 である必要があります。
+ `x-amz-server-side-encryption-customer-key` Amazon S3 でデータを暗号化または復号するために使用する base64 でエンコードされた 256 ビットの暗号化キーを指定するには、このヘッダーを使用します。
+ `x-amz-server-side-encryption-customer-key-MD5` RFC 1321 に従って、暗号化キーの base64 エンコードされた 128 ビット MD5 ダイジェストを指定するには、このヘッダーを使用します。Amazon S3 では、このヘッダーを使用してメッセージの整合性を調べて、送信された暗号化キーにエラーがないことを確認します。
### SSE-C で暗号化されたソースオブジェクトをコピーするリクエストに必要な S3 API ヘッダー
SSE-C で暗号化されたソースオブジェクトをコピーするには、次の 3 つの API ヘッダーを指定する必要があります。
+ `x-amz-copy-source-server-side-encryption-customer-algorithm` Amazon S3 でソースオブジェクトを復号するために使用するアルゴリズムを指定するには、このヘッダーを含めます。この値は、AES256 である必要があります。
+ `x-amz-copy-source-server-side-encryption-customer-key` Amazon S3 でソースオブジェクトを復号するために使用する base64 でエンコードされた暗号化キーを指定するには、このヘッダーを含めます。この暗号化キーは、Amazon S3 でソースオブジェクトを作成したときに指定したキーであることが必要です。それ以外の場合、Amazon S3 でオブジェクトを復号できません。
+ `x-amz-copy-source-server-side-encryption-customer-key-MD5` RFC 1321 に従って、暗号化キーの base64 エンコードされた 128 ビット MD5 ダイジェストを指定するには、このヘッダーを含めます。
## SSE-C 暗号化を適用するためのバケットポリシーの例
Amazon S3 バケットに書き込まれるすべてのオブジェクトに対して SSE-C を要求するには、バケットポリシーを使用できます。例えば、次のバケットポリシーは、SSE-C を要求する `x-amz-server-side-encryption-customer-algorithm` ヘッダーを含まないすべてのリクエストに対して、オブジェクトのアップロード (`s3:PutObject`) 許可を拒否します。
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "RequireSSECObjectUploads",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"Null": {
"s3:x-amz-server-side-encryption-customer-algorithm": "true"
}
}
}
]
}
```
**重要**
バケットポリシーを使用して `s3:PutObject` に対する SSE-C を要求する場合は、すべてのマルチパートアップロードリクエスト (CreateMultiPartUpload、UploadPart、CompleteMultipartUpload) に `x-amz-server-side-encryption-customer-algorithm` ヘッダーを含める必要があります。
## 署名済み URL および SSE−C
新しいオブジェクトのアップロード、既存のオブジェクトやオブジェクトメタデータの取得などのオペレーションに使用できる署名付き URL を生成できます。署名付き URL では、次のように SSE−C がサポートされます。
+ 署名付き URL を作成するときに、署名の計算で `x-amz-server-side-encryption-customer-algorithm` ヘッダーを使用してアルゴリズムを指定する必要があります。
+ 署名付き URL を使用して新しいオブジェクトをアップロードするとき、既存のオブジェクトを取得するとき、またはオブジェクトメタデータのみを取得するときに、クライアントアプリケーションのリクエストですべての暗号化ヘッダーを指定する必要があります。
**注記**
SSE−C 以外のオブジェクトでは、署名付き URL を生成し、その URL をブラウザに直接貼り付けることで、データにアクセスできます。
ただし、これは SSE−C オブジェクトには行えません。署名付き URL に加えて SSE−C オブジェクトに固有の HTTP ヘッダーも含める必要があります。したがって、SSE−C オブジェクトの署名付き URL はプログラムでのみ使用できます。
署名付き URL の詳細については、「 」を参照してください[署名付き URL を使用したオブジェクトのダウンロードおよびアップロード](using-presigned-url.md)
## SSE-C によるリクエストの作成
REST API を使用したオブジェクトの作成時に、お客様が用意したキー (SSE−C) を使用してサーバー側の暗号化を指定できます。SSE−C を使用する場合は、[SSE-C で暗号化されたソースオブジェクトをコピーするリクエストに必要な S3 API ヘッダー](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) を使用して暗号化キー情報を指定する必要があります。AWS SDK ラッパーライブラリを使用して、これらのヘッダーをリクエストに追加できます。必要に応じて、アプリケーションから直接 Amazon S3 REST API を呼び出すことができます。
**重要**
お客様が用意したキーによるサーバー側の暗号化 (SSE-C) を指定する前に、汎用バケットで SSE-C 暗号化がブロックされていないことを確認してください。詳細については、「[汎用バケットの SSE-C のブロックまたはブロック解除](blocking-unblocking-s3-c-encryption-gpb.md)」を参照してください。
**注記**
Amazon S3 コンソールを使用してオブジェクトをアップロードしたり SSE−C をリクエストしたりすることはできません。また、SSE−C を使用して保存されている既存のオブジェクトを更新すること (ストレージクラスの変更やメタデータの追加など) もできません。詳細については、「[SSE-C オブジェクトの暗号化および復号リクエストに必要な S3 API ヘッダー](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)」を参照してください。
## REST API の使用
### SSE−C をサポートする Amazon S3 REST API
次の Amazon S3 API は、お客様が用意した暗号化キー (SSE−C) を使用したサーバー側の暗号化をサポートします。
+ **GET オペレーション** — GET API ([GET Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html) を参照) を使用してオブジェクトを取得するときに、このリクエストヘッダーを指定できます。
+ **HEAD オペレーション** — HEAD API ([HEAD Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html) を参照) を使用してオブジェクトメタデータを取得するには、これらのリクエストヘッダーを指定できます。
+ **PUT オペレーション** — PUT API ([PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html) を参照) を使用してデータをアップロードするときに、これらのリクエストヘッダーを指定できます。
+ **マルチパートアップロード** — マルチパートアップロード API を使用して大きいオブジェクトをアップロードするときに、これらのヘッダーを指定できます。これらのヘッダーは、開始リクエスト ([Initiate Multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html) を参照) と、後続の各パートのアップロードリクエスト ([Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html) または [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html) を参照) で指定します。各パートのアップロードリクエストでは、暗号化情報がマルチパートアップロードの開始リクエストで指定した情報と同じである必要があります。
+ **POST オペレーション** — POST オペレーションを使用してオブジェクトをアップロードする場合は ([POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) を参照)、リクエストヘッダーの代わりに、フォームフィールドで同じ情報を指定します。
+ **Copy オペレーション** — オブジェクトをコピーする場合 ([CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) を参照)、ソースオブジェクトとターゲットオブジェクトがあります。
+ ターゲットオブジェクトの暗号化タイプを指定する場合は、`x-amz-server-side-encryption ` リクエストヘッダーを指定する必要があります。
+ SSE−C を使用してターゲットオブジェクトを暗号化する場合は、S3 API [SSE-C オブジェクトの暗号化および復号リクエストに必要な S3 API ヘッダー](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests) を使用して暗号化情報を指定する必要があります。
+ ソースオブジェクトが SSE−C を使用して暗号化されている場合は、S3 API ヘッダー [SSE-C で暗号化されたソースオブジェクトをコピーするリクエストに必要な S3 API ヘッダー](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) を使用して暗号化キー情報を指定する必要があります。
## AWS SDK を使用して PUT、GET、Head、および Copy オペレーションの SSE−C を指定する
次の例では、お客様が用意したキーによるサーバー側の暗号化 (SSE−C) をオブジェクト用にリクエストする方法を示します。この例では、次の操作を実行します。各オペレーションでは、SSE−C 関連ヘッダーをリクエストで指定する方法を示します。
+ **Put object** — オブジェクトをアップロードし、顧客が用意した暗号キーによるサーバー側の暗号化をリクエストします。
+ **Get object** — 前のステップでアップロードしたオブジェクトをダウンロードします。リクエストでは、オブジェクトのアップロード時に指定したのと同じ暗号化情報を提供します。Amazon S3 は、オブジェクトを復号して返すために、この情報を必要とします。
+ **Get object metadata** — オブジェクトのメタデータを取得します。オブジェクトの作成時に使用したのと同じ暗号化情報を指定します。
+ **Copy object** — 以前にアップロードしたオブジェクトのコピーを作成します。ソースオブジェクトは SSE−C を使用して保存されるため、コピーリクエストで暗号化情報を指定する必要があります。デフォルトでは、明示的にリクエストした場合に限り、Amazon S3 はオブジェクトのコピーを暗号化します。この例では、オブジェクトの暗号化されたコピーを保存するように Amazon S3 に指示します。
------
#### [ Java ]
**注記**
この例では、1 つのオペレーションでオブジェクトをアップロードする方法を示します。マルチパートアップロード API を使用して大きなオブジェクトをアップロードする場合は、この例に示したのと同じ方法で暗号化情報を指定します。AWS SDK for Java を使用するマルチパートアップロードの例については、[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md) を参照してください。
必要な暗号化情報を追加するには、リクエストに `SSECustomerKey` を含めます。`SSECustomerKey` クラスの詳細については、REST API」セクションを参照してください。
作業サンプルの作成およびテストの手順については、「AWS SDK for Java のデベロッパーガイド」の「[使用開始](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html)」を参照してください。
**Example**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.*;
import javax.crypto.KeyGenerator;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
public class ServerSideEncryptionUsingClientSideEncryptionKey {
private static SSECustomerKey SSE_KEY;
private static AmazonS3 S3_CLIENT;
private static KeyGenerator KEY_GENERATOR;
public static void main(String[] args) throws IOException, NoSuchAlgorithmException {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyName = "*** Key name ***";
String uploadFileName = "*** File path ***";
String targetKeyName = "*** Target key name ***";
// Create an encryption key.
KEY_GENERATOR = KeyGenerator.getInstance("AES");
KEY_GENERATOR.init(256, new SecureRandom());
SSE_KEY = new SSECustomerKey(KEY_GENERATOR.generateKey());
try {
S3_CLIENT = AmazonS3ClientBuilder.standard()
.withCredentials(new ProfileCredentialsProvider())
.withRegion(clientRegion)
.build();
// Upload an object.
uploadObject(bucketName, keyName, new File(uploadFileName));
// Download the object.
downloadObject(bucketName, keyName);
// Verify that the object is properly encrypted by attempting to retrieve it
// using the encryption key.
retrieveObjectMetadata(bucketName, keyName);
// Copy the object into a new object that also uses SSE-C.
copyObject(bucketName, keyName, targetKeyName);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
private static void uploadObject(String bucketName, String keyName, File file) {
PutObjectRequest putRequest = new PutObjectRequest(bucketName, keyName, file).withSSECustomerKey(SSE_KEY);
S3_CLIENT.putObject(putRequest);
System.out.println("Object uploaded");
}
private static void downloadObject(String bucketName, String keyName) throws IOException {
GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, keyName).withSSECustomerKey(SSE_KEY);
S3Object object = S3_CLIENT.getObject(getObjectRequest);
System.out.println("Object content: ");
displayTextInputStream(object.getObjectContent());
}
private static void retrieveObjectMetadata(String bucketName, String keyName) {
GetObjectMetadataRequest getMetadataRequest = new GetObjectMetadataRequest(bucketName, keyName)
.withSSECustomerKey(SSE_KEY);
ObjectMetadata objectMetadata = S3_CLIENT.getObjectMetadata(getMetadataRequest);
System.out.println("Metadata retrieved. Object size: " + objectMetadata.getContentLength());
}
private static void copyObject(String bucketName, String keyName, String targetKeyName)
throws NoSuchAlgorithmException {
// Create a new encryption key for target so that the target is saved using
// SSE-C.
SSECustomerKey newSSEKey = new SSECustomerKey(KEY_GENERATOR.generateKey());
CopyObjectRequest copyRequest = new CopyObjectRequest(bucketName, keyName, bucketName, targetKeyName)
.withSourceSSECustomerKey(SSE_KEY)
.withDestinationSSECustomerKey(newSSEKey);
S3_CLIENT.copyObject(copyRequest);
System.out.println("Object copied");
}
private static void displayTextInputStream(S3ObjectInputStream input) throws IOException {
// Read one line at a time from the input stream and display each line.
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
System.out.println();
}
}
```
------
#### [ .NET ]
**注記**
マルチパートアップロード API を使用した大きなオブジェクトのアップロードの例については、[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md) および [AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level) を参照してください。
コード例を設定および実行する方法の詳細については、「*AWS SDK for .NET デベロッパーガイド*」の「[AWS SDK for .NET の開始方法](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)」 を参照してください。
**Example**
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.IO;
using System.Security.Cryptography;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class SSEClientEncryptionKeyObjectOperationsTest
{
private const string bucketName = "*** bucket name ***";
private const string keyName = "*** key name for new object created ***";
private const string copyTargetKeyName = "*** key name for object copy ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 client;
public static void Main()
{
client = new AmazonS3Client(bucketRegion);
ObjectOpsUsingClientEncryptionKeyAsync().Wait();
}
private static async Task ObjectOpsUsingClientEncryptionKeyAsync()
{
try
{
// Create an encryption key.
Aes aesEncryption = Aes.Create();
aesEncryption.KeySize = 256;
aesEncryption.GenerateKey();
string base64Key = Convert.ToBase64String(aesEncryption.Key);
// 1. Upload the object.
PutObjectRequest putObjectRequest = await UploadObjectAsync(base64Key);
// 2. Download the object and verify that its contents matches what you uploaded.
await DownloadObjectAsync(base64Key, putObjectRequest);
// 3. Get object metadata and verify that the object uses AES-256 encryption.
await GetObjectMetadataAsync(base64Key);
// 4. Copy both the source and target objects using server-side encryption with
// a customer-provided encryption key.
await CopyObjectAsync(aesEncryption, base64Key);
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
private static async Task UploadObjectAsync(string base64Key)
{
PutObjectRequest putObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = keyName,
ContentBody = "sample text",
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
PutObjectResponse putObjectResponse = await client.PutObjectAsync(putObjectRequest);
return putObjectRequest;
}
private static async Task DownloadObjectAsync(string base64Key, PutObjectRequest putObjectRequest)
{
GetObjectRequest getObjectRequest = new GetObjectRequest
{
BucketName = bucketName,
Key = keyName,
// Provide encryption information for the object stored in Amazon S3.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
using (GetObjectResponse getResponse = await client.GetObjectAsync(getObjectRequest))
using (StreamReader reader = new StreamReader(getResponse.ResponseStream))
{
string content = reader.ReadToEnd();
if (String.Compare(putObjectRequest.ContentBody, content) == 0)
Console.WriteLine("Object content is same as we uploaded");
else
Console.WriteLine("Error...Object content is not same.");
if (getResponse.ServerSideEncryptionCustomerMethod == ServerSideEncryptionCustomerMethod.AES256)
Console.WriteLine("Object encryption method is AES256, same as we set");
else
Console.WriteLine("Error...Object encryption method is not the same as AES256 we set");
// Assert.AreEqual(putObjectRequest.ContentBody, content);
// Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getResponse.ServerSideEncryptionCustomerMethod);
}
}
private static async Task GetObjectMetadataAsync(string base64Key)
{
GetObjectMetadataRequest getObjectMetadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = keyName,
// The object stored in Amazon S3 is encrypted, so provide the necessary encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
GetObjectMetadataResponse getObjectMetadataResponse = await client.GetObjectMetadataAsync(getObjectMetadataRequest);
Console.WriteLine("The object metadata show encryption method used is: {0}", getObjectMetadataResponse.ServerSideEncryptionCustomerMethod);
// Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getObjectMetadataResponse.ServerSideEncryptionCustomerMethod);
}
private static async Task CopyObjectAsync(Aes aesEncryption, string base64Key)
{
aesEncryption.GenerateKey();
string copyBase64Key = Convert.ToBase64String(aesEncryption.Key);
CopyObjectRequest copyRequest = new CopyObjectRequest
{
SourceBucket = bucketName,
SourceKey = keyName,
DestinationBucket = bucketName,
DestinationKey = copyTargetKeyName,
// Information about the source object's encryption.
CopySourceServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
CopySourceServerSideEncryptionCustomerProvidedKey = base64Key,
// Information about the target object's encryption.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = copyBase64Key
};
await client.CopyObjectAsync(copyRequest);
}
}
}
```
------
## AWS SDK を使用してマルチパートアップロードの SSE−C を指定する
前のセクションの例では、PUT、GET、Head、および COPY オペレーションで、お客様が用意したキーによるサーバー側の暗号化 (SSE−C) をリクエストする方法を示しています。このセクションでは、SSE−C をサポートするその他の Amazon S3 API について説明します。
------
#### [ Java ]
大きなオブジェクトをアップロードするために、マルチパートアップロード API を使用できます。詳細については、「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照してください。高レベル API または低レベル API を使用して、大きなオブジェクトをアップロードできます。これらの API は、リクエストでの暗号化関連のヘッダーをサポートします。
+ 高レベルの `TransferManager` API を使用する場合は、`PutObjectRequest` で暗号化専用のヘッダーを指定します。詳細については、「[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md)」を参照してください。
+ 低レベル API を使用する場合は、暗号化関連情報を `InitiateMultipartUploadRequest` で指定し、続けて各 `UploadPartRequest` で同じ暗号化情報を指定します。`CompleteMultipartUploadRequest` で暗号化専用のヘッダーを指定する必要はありません。例については、[AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level) を参照してください。
次の例では、`TransferManager` を使用してオブジェクトを作成し、SSE−C 関連の情報を提供する方法を示します。この例では、次のような処理を実行します。
+ `TransferManager.upload()` メソッドを使用してオブジェクトを作成します。`PutObjectRequest` インスタンスでは、リクエストで暗号キーの情報を指定します。Amazon S3 は、お客様が用意したキーを使用してオブジェクトを暗号化します。
+ `TransferManager.copy()` メソッドを呼び出してオブジェクトのコピーを作成します。この例では、新しい `SSECustomerKey` を使用してオブジェクトのコピーを暗号化するように Amazon S3 に指示します。ソースオブジェクトは SSE−C で暗号化されているため、`CopyObjectRequest` はソースオブジェクトの暗号化キーを提供し、Amazon S3 で復号してからコピーできるようにします。
**Example**
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.CopyObjectRequest;
import com.amazonaws.services.s3.model.PutObjectRequest;
import com.amazonaws.services.s3.model.SSECustomerKey;
import com.amazonaws.services.s3.transfer.Copy;
import com.amazonaws.services.s3.transfer.TransferManager;
import com.amazonaws.services.s3.transfer.TransferManagerBuilder;
import com.amazonaws.services.s3.transfer.Upload;
import javax.crypto.KeyGenerator;
import java.io.File;
import java.security.SecureRandom;
public class ServerSideEncryptionCopyObjectUsingHLwithSSEC {
public static void main(String[] args) throws Exception {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String fileToUpload = "*** File path ***";
String keyName = "*** New object key name ***";
String targetKeyName = "*** Key name for object copy ***";
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
TransferManager tm = TransferManagerBuilder.standard()
.withS3Client(s3Client)
.build();
// Create an object from a file.
PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, keyName, new File(fileToUpload));
// Create an encryption key.
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(256, new SecureRandom());
SSECustomerKey sseCustomerEncryptionKey = new SSECustomerKey(keyGenerator.generateKey());
// Upload the object. TransferManager uploads asynchronously, so this call
// returns immediately.
putObjectRequest.setSSECustomerKey(sseCustomerEncryptionKey);
Upload upload = tm.upload(putObjectRequest);
// Optionally, wait for the upload to finish before continuing.
upload.waitForCompletion();
System.out.println("Object created.");
// Copy the object and store the copy using SSE-C with a new key.
CopyObjectRequest copyObjectRequest = new CopyObjectRequest(bucketName, keyName, bucketName, targetKeyName);
SSECustomerKey sseTargetObjectEncryptionKey = new SSECustomerKey(keyGenerator.generateKey());
copyObjectRequest.setSourceSSECustomerKey(sseCustomerEncryptionKey);
copyObjectRequest.setDestinationSSECustomerKey(sseTargetObjectEncryptionKey);
// Copy the object. TransferManager copies asynchronously, so this call returns
// immediately.
Copy copy = tm.copy(copyObjectRequest);
// Optionally, wait for the upload to finish before continuing.
copy.waitForCompletion();
System.out.println("Copy complete.");
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
}
```
------
#### [ .NET ]
大きなオブジェクトをアップロードするために、マルチパートアップロード API を使用できます (「[Amazon S3 でのマルチパートアップロードを使用したオブジェクトのアップロードとコピー](mpuoverview.md)」を参照)。AWSSDK for .NET には、大きなオブジェクトをアップロードするため、高レベルおよび低レベルの両方の API が用意されています。これらの API は、リクエストでの暗号化関連のヘッダーをサポートします。
+ 高レベルの `Transfer-Utility `API を使用するときには、次に示すように `TransferUtilityUploadRequest` で暗号化固有のヘッダーを提供します。コード例については、[マルチパートアップロードを使用したオブジェクトのアップロード](mpu-upload-object.md) を参照してください。
```
TransferUtilityUploadRequest request = new TransferUtilityUploadRequest()
{
FilePath = filePath,
BucketName = existingBucketName,
Key = keyName,
// Provide encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
```
+ 低レベル API を使用する場合は、マルチパートアップロードの開始リクエストで暗号化関連情報を提供し、以降のパートのアップロードリクエストでは同じ暗号化情報を提供します。マルチパートアップロードの完了リクエストでは、暗号化固有のヘッダーを提供する必要はありません。例については、[AWS SDK の使用 (低レベル API)](mpu-upload-object.md#mpu-upload-low-level) を参照してください。
既存の大きなオブジェクトをコピーする低レベルのマルチパートアップロードの例を次に示します。この例では、コピーされるオブジェクトは SSE−C を使用して Amazon S3 に保存されており、ターゲットオブジェクトも SSE−C を使用して保存します。例えば、以下を実行します。
+ 暗号化キーと関連情報を提供することによって、マルチパートアップロードのリクエストを開始します。
+ `CopyPartRequest` でソースオブジェクトとターゲットオブジェクトの暗号化キーを提供します。
+ オブジェクトメタデータを取得することによって、コピーされるソースオブジェクトのサイズを取得します。
+ 5 MB のパート単位でオブジェクトをアップロードします。
**Example**
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class SSECLowLevelMPUcopyObjectTest
{
private const string existingBucketName = "*** bucket name ***";
private const string sourceKeyName = "*** source object key name ***";
private const string targetKeyName = "*** key name for the target object ***";
private const string filePath = @"*** file path ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 s3Client;
static void Main()
{
s3Client = new AmazonS3Client(bucketRegion);
CopyObjClientEncryptionKeyAsync().Wait();
}
private static async Task CopyObjClientEncryptionKeyAsync()
{
Aes aesEncryption = Aes.Create();
aesEncryption.KeySize = 256;
aesEncryption.GenerateKey();
string base64Key = Convert.ToBase64String(aesEncryption.Key);
await CreateSampleObjUsingClientEncryptionKeyAsync(base64Key, s3Client);
await CopyObjectAsync(s3Client, base64Key);
}
private static async Task CopyObjectAsync(IAmazonS3 s3Client, string base64Key)
{
List uploadResponses = new List();
// 1. Initialize.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = existingBucketName,
Key = targetKeyName,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// 2. Upload Parts.
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
long firstByte = 0;
long lastByte = partSize;
try
{
// First find source object size. Because object is stored encrypted with
// customer provided key you need to provide encryption information in your request.
GetObjectMetadataRequest getObjectMetadataRequest = new GetObjectMetadataRequest()
{
BucketName = existingBucketName,
Key = sourceKeyName,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key // " * **source object encryption key ***"
};
GetObjectMetadataResponse getObjectMetadataResponse = await s3Client.GetObjectMetadataAsync(getObjectMetadataRequest);
long filePosition = 0;
for (int i = 1; filePosition < getObjectMetadataResponse.ContentLength; i++)
{
CopyPartRequest copyPartRequest = new CopyPartRequest
{
UploadId = initResponse.UploadId,
// Source.
SourceBucket = existingBucketName,
SourceKey = sourceKeyName,
// Source object is stored using SSE-C. Provide encryption information.
CopySourceServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
CopySourceServerSideEncryptionCustomerProvidedKey = base64Key, //"***source object encryption key ***",
FirstByte = firstByte,
// If the last part is smaller then our normal part size then use the remaining size.
LastByte = lastByte > getObjectMetadataResponse.ContentLength ?
getObjectMetadataResponse.ContentLength - 1 : lastByte,
// Target.
DestinationBucket = existingBucketName,
DestinationKey = targetKeyName,
PartNumber = i,
// Encryption information for the target object.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
uploadResponses.Add(await s3Client.CopyPartAsync(copyPartRequest));
filePosition += partSize;
firstByte += partSize;
lastByte += partSize;
}
// Step 3: complete.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = existingBucketName,
Key = targetKeyName,
UploadId = initResponse.UploadId,
};
completeRequest.AddPartETags(uploadResponses);
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("Exception occurred: {0}", exception.Message);
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = targetKeyName,
UploadId = initResponse.UploadId
};
s3Client.AbortMultipartUpload(abortMPURequest);
}
}
private static async Task CreateSampleObjUsingClientEncryptionKeyAsync(string base64Key, IAmazonS3 s3Client)
{
// List to store upload part responses.
List uploadResponses = new List();
// 1. Initialize.
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest
{
BucketName = existingBucketName,
Key = sourceKeyName,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
InitiateMultipartUploadResponse initResponse =
await s3Client.InitiateMultipartUploadAsync(initiateRequest);
// 2. Upload Parts.
long contentLength = new FileInfo(filePath).Length;
long partSize = 5 * (long)Math.Pow(2, 20); // 5 MB
try
{
long filePosition = 0;
for (int i = 1; filePosition < contentLength; i++)
{
UploadPartRequest uploadRequest = new UploadPartRequest
{
BucketName = existingBucketName,
Key = sourceKeyName,
UploadId = initResponse.UploadId,
PartNumber = i,
PartSize = partSize,
FilePosition = filePosition,
FilePath = filePath,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key
};
// Upload part and add response to our list.
uploadResponses.Add(await s3Client.UploadPartAsync(uploadRequest));
filePosition += partSize;
}
// Step 3: complete.
CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest
{
BucketName = existingBucketName,
Key = sourceKeyName,
UploadId = initResponse.UploadId,
//PartETags = new List(uploadResponses)
};
completeRequest.AddPartETags(uploadResponses);
CompleteMultipartUploadResponse completeUploadResponse =
await s3Client.CompleteMultipartUploadAsync(completeRequest);
}
catch (Exception exception)
{
Console.WriteLine("Exception occurred: {0}", exception.Message);
AbortMultipartUploadRequest abortMPURequest = new AbortMultipartUploadRequest
{
BucketName = existingBucketName,
Key = sourceKeyName,
UploadId = initResponse.UploadId
};
await s3Client.AbortMultipartUploadAsync(abortMPURequest);
}
}
}
}
```
------
# 汎用バケットの SSE-C のブロックまたはブロック解除
Amazon S3 の最新のユースケースでは、Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) または AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の柔軟性がないため、お客様が用意したキーによるサーバー側の暗号化 (SSE-C) は使用されなくなりました。SSE-C では、SSE-C 暗号化データとやり取りするたびに暗号化キーを提供する必要があるため、S3 バケットからデータを読み取ってデータを操作しようとする他のユーザー、ロール、または AWS のサービスと SSE-C キーを共有することは実用的ではありません。
汎用バケットで使用できるサーバー側の暗号化タイプを制限するには、バケットのデフォルトの暗号化設定を更新して SSE-C 書き込みリクエストをブロックすることを選択できます。このバケットレベルの設定は、SSE-C を指定するオブジェクトをアップロードするリクエストをブロックします。バケットに対して SSE-C がブロックされている場合、SSE-C 暗号化を指定する `PutObject`、`CopyObject`、`PostObject`、またはマルチパートアップロードまたはレプリケーションリクエストは、HTTP 403 `AccessDenied` エラーで拒否されます。
この設定は `PutBucketEncryption` API のパラメータであり、`s3:PutEncryptionConfiguration` アクセス許可がある場合は S3 コンソール、AWS CLI、および AWS SDK を使用して更新することもできます。
有効な値は、汎用バケットの SSE-C 暗号化をブロックする `SSE-C` と、バケットへの書き込みに SSE-C を使用できるようにする `NONE` です。
**重要**
2026 年 4 月以降、AWS はすべての新しいバケットについて、お客様が用意したキー (SSE-C) によるサーバー側の暗号化を無効にします。さらに、SSE-C 暗号化は、SSE-C 暗号化データを持たない AWS アカウントのすべての既存のバケットに対して無効になります。これらの変更により、SSE-C 暗号化を必要とする少数のアプリケーションは、バケットの作成後に [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API を介して SSE-C の使用を意図的に有効にする必要があります。このような場合、自動化スクリプト、CloudFormation テンプレート、またはその他のインフラストラクチャ設定ツールを更新して、これらの設定を構成する必要がある場合があります。詳細については、[AWS ストレージブログ記事](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/)を参照してください。
## アクセス許可
`PutBucketEncryption` API または S3 コンソール、AWS SDK、または AWS CLI を使用して、汎用バケットの暗号化タイプをブロックまたはブロック解除します。次のアクセス許可が必要です。
+ `s3:PutEncryptionConfiguration`
`GetBucketEncryption` API または S3 コンソール、AWS SDK、または AWS CLI を使用して、汎用バケットのブロックされた暗号化タイプを表示します。次のアクセス許可が必要です。
+ `s3:GetEncryptionConfiguration`
## SSE-C 暗号化をブロックする前の考慮事項
バケットの SSE-C をブロックすると、次の暗号化動作が適用されます。
+ SSE-C 暗号化をブロックする前にバケットに存在していたオブジェクトの暗号化は、変更されません。
+ SSE-C 暗号化をブロックした後、リクエストに必要な SSE-C ヘッダーを提供する限り、SSE-C で暗号化された既存のオブジェクトに対して GetObject および HeadObject リクエストを引き続き実行できます。
+ バケットに対して SSE-C がブロックされている場合、SSE-C 暗号化を指定する `PutObject`、`CopyObject`、`PostObject`、またはマルチパートアップロードリクエストは、HTTP 403 `AccessDenied` エラーで拒否されます。
+ レプリケーションの送信先バケットで SSE-C がブロックされ、レプリケートされるソースオブジェクトが SSE-C で暗号化されている場合、レプリケーションは HTTP 403 `AccessDenied` エラーで失敗します。
この暗号化タイプをブロックする前に、いずれかのバケットで SSE-C 暗号化を使用しているかどうかを確認する場合は、[AWS CloudTrail](https://aws.amazon.com/cloudtrail/) などのツールを使用してデータへのアクセスをモニタリングできます。この[ブログ記事](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/)では、オブジェクトのアップロードの暗号化方法をリアルタイムで監査する方法を示します。この [re:Post 記事](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets)を参照して、S3 インベントリレポートのクエリを実行して、SSE-C で暗号化されたオブジェクトがあるかどうかを確認することもできます。
### Steps
Amazon S3 コンソール、AWS Command Line Interface (AWS CLI)、Amazon S3 REST API、および AWS SDK を使用して、汎用バケットのお客様が用意したキーによるサーバー側の暗号化 (SSE-C) をブロックまたはブロック解除できます。
### S3 コンソールの使用
Amazon S3 コンソールを使用してバケットの SSE-C 暗号化をブロックまたはブロック解除するには。
1. AWS マネジメントコンソールにサインインして Amazon S3 コンソール (https://console.aws.amazon.com/s3/) を開きます。
1. 左のナビゲーションペインで、**[汎用バケット]** を選択します。
1. SSE-C 暗号化をブロックするバケットを選択します。
1. バケットの **[プロパティ]** タブを選択します。
1. バケットの **[デフォルトの暗号化]** プロパティパネルに移動し、**[編集]** を選択します。
1. **[ブロックされた暗号化タイプ]** セクションで、**[お客様が用意したキーによるサーバー側の暗号化 (SSE-C)]** の横にあるチェックボックスをオンにして SSE-C 暗号化をブロックするか、このチェックボックスをオフにして SSE-C を許可します。
1. **[Save Changes]** (変更を保存) をクリックします。
### の使用AWS CLI
AWS CLI をインストールする方法については、「*AWS Command Line Interface ユーザーガイド*」の「[AWS CLI のインストール](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)」を参照してください。
次の CLI の例は、AWS CLI を使用して汎用バケットの SSE-C 暗号化をブロックまたはブロック解除する方法を示しています。このコマンドを使用する際は、*ユーザー入力用プレースホルダー*を独自の情報に置き換えます。
**汎用バケットの SSE-C 暗号化をブロックするリクエスト:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "SSE-C"
}
}]
}'
```
**汎用バケットで SSE-C 暗号化の使用を有効にするリクエスト:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "NONE"
}
}]
}'
```
## AWS SDK の使用
------
#### [ SDK for Java 2.x ]
次の例は、AWS SDK を使用して汎用バケットへの SSE-C 暗号化書き込みをブロックまたはブロック解除する方法を示しています。
**例 - PutBucketEncryption リクエストでデフォルトの暗号化設定を SSE-S3 に設定し、SSE-C をブロックする**
```
S3Client s3Client = ...;
ServerSideEncryptionByDefault defaultSse = ServerSideEncryptionByDefault
.builder()
.sseAlgorithm(ServerSideEncryption.AES256)
.build();
BlockedEncryptionTypes blockedEncryptionTypes = BlockedEncryptionTypes
.builder()
.encryptionType(EncryptionType.SSE_C)
.build();
ServerSideEncryptionRule rule = ServerSideEncryptionRule.builder()
.applyServerSideEncryptionByDefault(defaultSse)
.blockedEncryptionTypes(blockedEncryptionTypes)
.build();
s3Client.putBucketEncryption(be -> be
.bucket(bucketName)
.serverSideEncryptionConfiguration(c -> c.rules(rule)));
```
**例 - PutBucketEncryption リクエストでデフォルトの暗号化設定を SSE-S3 に設定し、SSE-C のブロックを解除する**
```
S3Client s3Client = ...;
ServerSideEncryptionByDefault defaultSse = ServerSideEncryptionByDefault
.builder()
.sseAlgorithm(ServerSideEncryption.AES256)
.build();
BlockedEncryptionTypes blockedEncryptionTypes = BlockedEncryptionTypes
.builder()
.encryptionType(EncryptionType.NONE)
.build();
ServerSideEncryptionRule rule = ServerSideEncryptionRule.builder()
.applyServerSideEncryptionByDefault(defaultSse)
.blockedEncryptionTypes(blockedEncryptionTypes)
.build();
s3Client.putBucketEncryption(be -> be
.bucket(bucketName)
.serverSideEncryptionConfiguration(c -> c.rules(rule)));
```
------
#### [ SDK for Python Boto3 ]
**例 - PutBucketEncryption リクエストでデフォルトの暗号化設定を SSE-S3 に設定し、SSE-C をブロックする**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["SSE-C"]
}
}]
}
)
```
**例 - PutBucketEncryption リクエストでデフォルトの暗号化設定を SSE-S3 に設定し、SSE-C のブロックを解除する**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["NONE"]
}
}]
}
)
```
------
## REST API の使用
汎用バケットの SSE-C 暗号化のブロックまたはブロック解除に関する Amazon S3 REST API サポートの詳細については、「*Amazon Simple Storage Service API リファレンス*」の次のセクションを参照してください。
+ [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) および [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html) API オペレーションの [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html) データ型で使用される [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html) データ型。
# 新しいバケットの SSE-C 設定に関するよくある質問
**重要**
2026 年 4 月以降、AWS はすべての新しいバケットについて、お客様が用意したキー (SSE-C) によるサーバー側の暗号化を無効にします。さらに、SSE-C 暗号化は、SSE-C 暗号化データを持たない AWS アカウントのすべての既存のバケットに対して無効になります。これらの変更により、SSE-C 暗号化を必要とする少数のアプリケーションは、バケットの作成後に [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API を介して SSE-C の使用を意図的に有効にする必要があります。このような場合、自動化スクリプト、CloudFormation テンプレート、またはその他のインフラストラクチャ設定ツールを更新して、これらの設定を構成する必要がある場合があります。詳細については、[AWS ストレージブログ記事](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/)を参照してください。
以下のセクションでは、この更新に関する質問に答えます。
**1. 2026 年 4 月には、新しく作成されたすべてのバケットに新しい SSE-C 設定が適用されますか?**
はい。2026 年 4 月中に、新しいデフォルト設定がすべての AWS リージョンに徐々に展開されます。
**2. このロールアウトがすべての AWS リージョンをカバーするまでにはどれくらいの時間がかかりますか?**
このアップデートの導入には数週間かかります。このアップデートの導入開始時には、「最新情報」の記事を公開します。
**3. 更新が完了したかどうかはどうすればわかりますか?**
新しいバケットを作成し、[GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html) API オペレーションを呼び出して SSE-C 暗号化が無効になっているかどうかを判断することで、ユーザーの AWS リージョンで変更が完了したかどうかを簡単に判断できます。更新が完了すると、すべての新しい汎用バケットでは SSE-C 暗号化がデフォルトで自動的に無効になります。これらの設定は、S3 バケットの作成後に [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API オペレーションを呼び出して調整できます。
**4. Amazon S3 は既存のバケット設定を更新しますか?**
AWS アカウントに SSE-C 暗号化オブジェクトがない場合、AWS は既存のすべてのバケットで SSE-C 暗号化を無効にします。AWS アカウントのバケットに SSE-C で暗号化されたオブジェクトがある場合、AWS はそのアカウントのバケットのバケット設定を変更しません。AWS リージョン `CreateBucket` の変更が完了すると、新しいデフォルト設定がすべての新しい汎用バケットに適用されます。
**5. 更新が完了する前にバケットの SSE-C 暗号化を無効にすることはできますか?**
はい。[PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API オペレーションを呼び出して新しい `BlockedEncryptionTypes` ヘッダーを指定することで、任意のバケットの SSE-C 暗号化を無効にすることができます。
**6. SSE-C を使用して新しいバケット内のデータを暗号化できますか?**
はい。Amazon S3 の最新のユースケースのほとんどでは、Amazon S3 マネージドキーによるサーバー側の暗号化 (SSE-S3) や AWS KMS キーによるサーバー側の暗号化 (SSE-KMS) の柔軟性が欠けているため、SSE-C は使用されなくなりました。新しいバケットで SSE-C 暗号化を使用する必要がある場合は、新しいバケットを作成してから、別の `PutBucketEncryption` リクエストで SSE-C 暗号化の使用を有効にすることができます。
**例**
```
aws s3api create-bucket \
bucket amzn-s3-demo-bucket \
region us-east-1 \
aws s3api put-bucket-encryption \
-- bucket amzn-s3-demo-bucket \
-- server-side-encryption-configuration \
'{ \Rules\: [{
{
\ApplyServerSideEncryptionByDefault\: {
\SSEAlgorithm\: \AES256\,
},
\BlockedEncryptionTypes\: [
\EncryptionType\:\NONE\]
}
}]
}'
```
**注記**
`PutBucketEncryption` API を呼び出すには、`s3:PutEncryptionConfiguration` アクセス許可が必要です。
**7. SSE-C をブロックすると、バケットへのリクエストにどのような影響がありますか?**
バケットに対して SSE-C がブロックされている場合、SSE-C 暗号化を指定する `PutObject`、`CopyObject`、`PostObject`、またはマルチパートアップロードまたはレプリケーションリクエストは、HTTP 403 `AccessDenied` エラーで拒否されます。
# クライアント側の暗号化を使用したデータの保護
*クライアント側の暗号化*は、データをローカルで暗号化することで、転送時および保管時のセキュリティを確保するためのものです。Amazon S3 に送信する前にオブジェクトを暗号化するには、Amazon S3 暗号化クライアントを使用します。オブジェクトがこの方法で暗号化されている場合、オブジェクトは AWS を含むサードパーティーに公開されません。Amazon S3 は、すでに暗号化されているオブジェクトを受け取るだけで、オブジェクトの暗号化または復号には関与しません。Amazon S3 暗号化クライアントと[サーバー側の暗号化](serv-side-encryption.md)の両方を使用してデータを暗号化できます。暗号化されたオブジェクトを Amazon S3 に送信すると、Amazon S3 はオブジェクトを暗号化されているとは認識せず、一般的なオブジェクトのみを検出します。
Amazon S3 暗号化クライアントは、お客様と Amazon S3 の間の仲介役として機能します。Amazon S3 暗号化クライアントをインスタンス化すると、オブジェクトは、Amazon S3 `PutObject` および `GetObject` リクエストの一部として自動的に暗号化および復号化されます。オブジェクトはすべて、一意のデータキーで暗号化されます。Amazon S3 暗号化クライアントは、ラップキーとして KMS キーを指定した場合でも、バケットキーを使用したり、バケットキーを操作したりしません。
*Amazon S3 暗号化クライアント開発者ガイド*は、Amazon S3 暗号化クライアントのバージョン 3.0 以降に焦点を当てています。詳細については、*Amazon S3 暗号化クライアントデベロッパーガイド*の「[What is the Amazon S3 Encryption Client?](https://docs.aws.amazon.com//amazon-s3-encryption-client/latest/developerguide/what-is-s3-encryption-client.html)」(Amazon S3 暗号化クライアントとは) を参照してください。
Amazon S3 暗号化クライアントの以前のバージョンの詳細については、プログラミング言語に応じた AWS SDK デベロッパーガイドを参照してください。
+ [AWS SDK for Java](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/examples-crypto.html)
+ [AWS SDK for .NET](https://docs.aws.amazon.com//sdk-for-net/v3/developer-guide/kms-keys-s3-encryption.html)
+ [AWS SDK for Go](https://docs.aws.amazon.com//sdk-for-go/v1/developer-guide/welcome.html)
+ [AWS SDK for PHP](https://docs.aws.amazon.com//sdk-for-php/v3/developer-guide/s3-encryption-client.html)
+ [AWS SDK for Ruby](https://docs.aws.amazon.com//sdk-for-ruby/v3/api/Aws/S3/Encryption.html)
+ [AWS SDK for C\$1\$1](https://docs.aws.amazon.com//sdk-for-cpp/v1/developer-guide/welcome.html)
# 暗号化を使用して転送中のデータを保護する
Amazon S3 は、データ転送用の HTTP プロトコルと HTTPS プロトコルの両方をサポートしています。HTTP はプレーンテキストでデータを送信し、HTTPS は Transport Layer Security (TLS) を使用してデータを暗号化することでセキュリティレイヤーを追加します。TLS は、盗聴、データ改ざん、中間者攻撃から保護します。HTTP トラフィックは受け入れられますが、ほとんどの実装では、HTTPS および TLS による転送中の暗号化を使用して、クライアントと Amazon S3 間のデータを保護します。
## TLS 1.2 および TLS 1.3 のサポート
Amazon S3 は、すべての AWS リージョンのすべての API エンドポイントでの HTTPS 接続に TLS 1.2 および TLS 1.3 をサポートしています。S3 は、クライアントソフトウェアでサポートされている最も強力な TLS 保護と、アクセスしている S3 エンドポイントを自動的にネゴシエートします。AWS SDK と AWS CLI を含む現在の AWS ツール (2014 以降) は、デフォルトで自動的に TLS 1.3 になり、ユーザー側でアクションは必要ありません。TLS 1.2 との下位互換性が必要な場合は、この自動ネゴシエーションをクライアント設定で上書きして、特定の TLS バージョンを指定できます。TLS 1.3 を使用する場合、オプションでハイブリッドポスト量子キー交換 (ML-KEM) を設定して、Amazon S3 への量子耐性リクエストを行うことができます。詳細については、「[クライアントのハイブリッドポスト量子 TLS の設定](pqtls-how-to.md)」を参照してください。
**注記**
TLS 1.3 は、Amazon S3 の AWS PrivateLink およびマルチリージョンアクセスポイントを除くすべての S3 エンドポイントでサポートされています。
## TLS 使用状況のモニタリング
Amazon S3 サーバーアクセスログまたは AWS CloudTrail を使用して、Amazon S3 バケットへのリクエストをモニタリングできます。どちらのログ記録オプションも、各リクエストで使用される TLS バージョンと暗号スイートを記録します。
+ **Amazon S3 サーバーアクセスログ** – サーバーアクセスログ記録には、バケットに対して行われたリクエストの詳細が記録されます。例えば、アクセスのログ情報は、セキュリティやアクセスの監査に役立ちます。詳細については、「[Amazon S3 サーバーアクセスログの形式](LogFormat.md)」を参照してください。
+ **AWS CloudTrail** – [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) は、ユーザーやロール、AWS サービスによって実行されたアクションを記録するサービスです。Amazon S3 へのすべての API コールをイベントとしてキャプチャします。詳細については、「[Amazon S3 CloudTrail イベント](cloudtrail-logging-s3-info.md)」を参照してください。
## 転送時の暗号化の強制
Amazon S3 への転送中のデータの暗号化を適用することは、セキュリティのベストプラクティスです。さまざまなポリシーメカニズムを使用して、HTTPS のみの通信や特定の TLS バージョンの使用を適用できます。これには、S3 バケット ([バケットポリシー](bucket-policies.md))、[サービスコントロールポリシー](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) (SCP)、[リソースコントロールポリシー](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html) (RCP)、[VPC エンドポイントポリシー](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)の IAM リソースベースのポリシーが含まれます。
### 転送中の暗号化を適用するためのバケットポリシーの例
[S3 条件キー](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html#amazons3-policy-keys) `s3:TlsVersion` を使用して、クライアントが使用する TLS バージョンに基づいて Amazon S3 バケットへのアクセスを制限できます。詳細については、「[例 6: 最小の TLS バージョンの要求](amazon-s3-policy-keys.md#example-object-tls-version)」を参照してください。
**Example `S3:TlsVersion` 条件キーを使用して TLS 1.3 を適用するバケットポリシー**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyInsecureConnections",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
],
"Condition": {
"NumericLessThan": {
"s3:TlsVersion": "1.3"
}
}
}
]
}
```
S3 バケットポリシーの `aws:SecureTransport` [グローバル条件キー](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)を使用して、リクエストが HTTPS (TLS) 経由で送信されたかどうかを確認できます。前の例とは異なり、この条件は特定の TLS バージョンをチェックしません。詳細については、「[HTTPS リクエストのみにアクセスを制限](example-bucket-policies.md#example-bucket-policies-use-case-HTTP-HTTPS-1)」を参照してください。
**Example `aws:SecureTransport` グローバル条件キーを使用して HTTPS を適用するバケットポリシー**
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RestrictToTLSRequestsOnly",
"Action": "s3:*",
"Effect": "Deny",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
],
"Condition": {
"Bool": {
"aws:SecureTransport": "false"
}
},
"Principal": "*"
}
]
}
```
**両方のキーに基づくポリシーの例と、その他の例**
前の例の両方のタイプの条件キーを 1 つのポリシーで使用できます。詳細とその他の適用アプローチについては、AWS ストレージブログ記事の「[Amazon S3 で TLS1.2 以上を使用して転送中の暗号化を強制する](https://aws.amazon.com/blogs/storage/enforcing-encryption-in-transit-with-tls1-2-or-higher-with-amazon-s3/)」を参照してください。
# Amazon S3 でハイブリッドポスト量子 TLS を使用する
Amazon S3 は、TLS ネットワーク暗号化プロトコル用のハイブリッドポスト量子キー交換オプションもサポートしています。この TLS オプションは、TLS 1.3 を使用して Amazon S3 エンドポイントにリクエストを行うときに使用できます。S3 が TLS セッションでサポートしている従来の暗号スイートにより、現在のテクノロジーではキー交換メカニズムに対するブルートフォース攻撃は実行不可能です。しかし、暗号に関連した量子コンピュータが将来実用的になると、TLS 鍵交換メカニズムで使用される従来の暗号スイートは、これらの攻撃の影響を受けやすくなります。現在、業界では、従来の要素とポスト量子要素を組み合わせたハイブリッドポスト量子キー交換が主流となっており、TLS 接続が従来の暗号スイートと同等以上の強度を保つことが保証されています。Amazon S3 は、現在、業界標準の IANA 仕様に準拠したハイブリッド PQ-TLS をサポートしています。
TLS 接続を介して渡されるデータの長期的な機密性に依存するアプリケーションを開発する場合は、大規模な量子コンピュータが使用可能になる前に、量子後の暗号化に移行する計画を検討する必要があります。責任共有モデルの一環として、S3 はサービスエンドポイントで量子安全暗号化を有効にします。ブラウザとアプリケーションが PQ-TLS を有効にすると、S3 は転送中のデータを保護するために可能な限り強力な設定を選択します。
**サポートされているエンドポイントタイプと AWS リージョン**
Amazon S3 のポスト量子 TLS は、すべての AWS リージョンで使用できます。各 AWS リージョンの S3 エンドポイントのリストについては、「*Amazon Web Services 全般のリファレンス*」の「[Amazon Simple Storage Service エンドポイントとクォータ](https://docs.aws.amazon.com/general/latest/gr/s3.html)」を参照してください。
**注記**
ハイブリッドポスト量子 TLS は、Amazon S3 の AWS PrivateLink、マルチリージョンアクセスポイント、および S3 Vectors を除くすべての S3 エンドポイントでサポートされています。
## Amazon S3 でハイブリッドポスト量子 TLS を使用する
ハイブリッドポスト量子 TLS をサポートするには、Amazon S3 にリクエストを行うクライアントを設定する必要があります。HTTP クライアントのテスト環境または本番稼働環境を設定するときは、次の点に注意してください。
**転送時の暗号化**
ハイブリッドポスト量子 TLS は、転送中の暗号化にのみ使用されます。これにより、クライアントから S3 エンドポイントに送信される間、データが保護されます。この新しいサポートは、デフォルトで AES-256 アルゴリズムを利用する Amazon S3 のサーバー側の暗号化と組み合わされ、転送中と保管時の両方の量子耐性暗号化を提供します。Amazon S3 のサーバー側暗号化の詳細については、「[サーバー側の暗号化によるデータの保護](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html)」をご参照ください。
**サポートされているクライアント**
ハイブリッドポスト量子 TLS を使用するには、この機能をサポートするクライアントを使用する必要があります。AWSSDK とツールには、言語やランタイムによって異なる暗号化機能と設定があります。特定のツールのポスト量子暗号化の詳細については、「[ハイブリッドポスト量子 TLS の有効化](https://docs.aws.amazon.com/payment-cryptography/latest/userguide/pqtls-details.html)」を参照してください。
**注記**
Amazon S3 へのリクエストの PQ-TLS キー交換の詳細は、AWS CloudTrail イベントまたは S3 サーバーアクセスログでは使用できません。
## ポスト量子 TLS について
ハイブリッドポスト量子 TLS の使用の詳細については、次のリソースを参照してください。
+ ブログ記事や研究論文へのリンクなど、AWS でのポスト量子暗号の詳細については、「[AWS 用ポスト量子暗号](https://aws.amazon.com/security/post-quantum-cryptography/)」を参照してください。
+ s2n-tls の詳細については、「[新しいオープンソース TLS 実装である s2n-tls の導入](https://aws.amazon.com/blogs/security/introducing-s2n-a-new-open-source-tls-implementation/)」と「[s2n-tls の使用](https://github.com/aws/s2n-tls/tree/main/docs/usage-guide)」を参照してください。
+ AWS 共通ランタイム HTTP クライアントについては、「*AWS SDK for Java 2.x デベロッパーガイド*」の「[AWS CRT ベースの HTTP クライアントの設定](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/http-configuration-crt.html)」を参照してください。
+ 米国国立標準技術研究所 (NIST) のポスト量子暗号プロジェクトの詳細については、「[Post-Quantum Cryptography](https://csrc.nist.gov/Projects/Post-Quantum-Cryptography)」(ポスト量子暗号化) を参照してください。
+ NIST ポスト量子暗号標準化については、NIST の「[ポスト量子暗号標準化](https://csrc.nist.gov/Projects/post-quantum-cryptography/post-quantum-cryptography-standardization)」を参照してください。
# クライアントのハイブリッドポスト量子 TLS の設定
Amazon S3 で PQ-TLS を使用するには、ポスト量子キー交換アルゴリズムをサポートするようにクライアントを設定する必要があります。また、クライアントがハイブリッドアプローチをサポートしていることを確認します。ハイブリッドアプローチは、従来の楕円曲線暗号と ML-KEM (Module-Lattice-Based キーカプセル化メカニズム) などのポスト量子アルゴリズムを組み合わせたものです。
特定の設定は、クライアントライブラリとプログラミング言語によって異なります。詳細については、「[ハイブリッドポスト量子 TLS の有効化](https://docs.aws.amazon.com/payment-cryptography/latest/userguide/pqtls-details.html)」を参照してください。
## クライアント設定の例: AWS SDK for Java 2
この手順では、AWS 共通ランタイム HTTP クライアントの Maven 依存関係を追加します。次に、ポスト量子 TLS を優先する HTTP クライアントを設定します。次に、HTTP クライアントを使用する Amazon S3 クライアントを作成します。
**注記**
プレビューとして公開された AWS 共通ランタイム HTTP クライアントは、2023 年 2 月に一般公開されました。このリリースでは、`tlsCipherPreference` クラスと `tlsCipherPreference()` メソッドパラメータが、`postQuantumTlsEnabled()` メソッドパラメータに置き換えられました。プレビュー中にこの例を使用していた場合は、コードを更新する必要があります。
1. Maven 依存関係に AWS 共通ランタイムクライアントを追加します。利用可能な最新バージョンを使用することをお勧めします。
例えば、このステートメントは Maven の依存関係に、AWS 共通ランタイムクライアントのバージョン `2.30.22` を追加します。
```
software.amazon.awssdk
aws-crt-client
2.30.22
```
1. ハイブリッドポスト量子暗号スイートを有効にするには、AWS SDK for Java 2.x をプロジェクトに追加して初期化します。続いて、次の例に示すように、HTTP クライアントでハイブリッドポスト量子暗号スイートを有効にします。
このコードでは、`postQuantumTlsEnabled()` メソッドパラメータを使用して、推奨されるハイブリッドポスト量子暗号スイートである ECDH with ML-KEM を優先する [AWS 共通ランタイム HTTP クライアント](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/http-configuration-crt.html)を設定します。次に、設定済み HTTP クライアントを使用して、Amazon S3 非同期クライアントのインスタンスである [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html) を構築します。このコードが完了すると、`S3AsyncClient` インスタンス上のすべての [Amazon S3 API](https://docs.aws.amazon.com/AmazonS3/latest/API/) リクエストは、ハイブリッドポスト量子 TLS を使用します。
**重要**
v2.35.11 以降、クライアントでハイブリッドポスト量子 TLS を有効にするように `.postQuantumTlsEnabled(true)` を設定する必要がなくなりました。v2.35.11 より新しいすべてのバージョンは、デフォルトでポスト量子 TLS を有効にします。
```
// Configure HTTP client
SdkAsyncHttpClient awsCrtHttpClient = AwsCrtAsyncHttpClient.builder()
.postQuantumTlsEnabled(true)
.build();
// Create the Amazon S3 async client
S3AsyncClient s3Async = S3AsyncClient.builder()
.httpClient(awsCrtHttpClient)
.build();
```
1. ハイブリッドポスト量子 TLS を使用して Amazon S3 の呼び出しをテストします。
構成された Amazon S3 クライアントで Amazon S3 API オペレーションを呼び出すと、コールはハイブリッドポスト量子 TLS を使用して Amazon S3 エンドポイントに送信されます。設定をテストするには、`[ListBuckets](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html)` などの Amazon S3 API を呼び出します。
```
ListBucketsResponse reponse = s3Async.listBuckets();
```
### ハイブリッドポスト量子 TLS 設定をテストする
Amazon S3 を呼び出すアプリケーションで、ハイブリッド暗号スイートを使用して次のテストを実行することを検討してください。
+ 負荷テストとベンチマークを実行します。ハイブリッド暗号スイートの動作は、従来のキー交換アルゴリズムとは異なります。ハンドシェイク時間が長くなるように、接続のタイムアウトを調整する必要がある場合があります。AWS Lambda 関数内で実行している場合は、実行タイムアウト設定を拡張します。
+ 別の場所からの接続を試します。要求が通過するネットワークパスによっては、ディープパケットインスペクション (DPI) を持つ中間ホスト、プロキシ、またはファイアウォールが要求をブロックしていることが検出されることがあります。これは、TLS ハンドシェイクの [ClientHello](https://tools.ietf.org/html/rfc5246#section-7.4.1.2) 部分で新しい暗号スイートを使用した場合や、大きなキー交換メッセージから発生することがあります。これらの問題を解決できない場合は、セキュリティチームまたは IT 管理者と協力して、関連する構成を更新し、新しい TLS 暗号スイートのブロックを解除してください。