# 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)」の例を参照してください。