Amazon S3 관리형 키를 사용한 서버 측 암호화(SSE-S3) 지정

AWS SDK for Java를 사용하여 객체를 업로드할 때 SSE-S3를 사용하여 객체를 암호화할 수 있습니다. 서버 측 암호화를 요청하려면 ObjectMetadata의 PutObjectRequest 속성을 사용하여 x-amz-server-side-encryption 요청 헤더를 설정합니다. AmazonS3Client의 putObject() 메서드를 호출할 때 Amazon S3에서는 데이터를 암호화해 저장합니다.

멀티파트 업로드 API 작업을 사용하여 객체를 업로드할 때도 SSE-S3 암호화를 요청할 수 있습니다.

객체의 암호화 상태는 직접 변경할 수 없습니다(암호화되지 않은 객체 암호화 또는 암호화된 객체 암호 해독). 객체의 암호화 상태를 변경하려면 객체를 복사한 다음 사본에 대해 원하는 암호화 상태를 지정한 후 원본 객체를 삭제합니다. Amazon S3에서는 서버 측 암호화를 명시적으로 요청한 경우에만 객체의 사본을 암호화합니다. Java API를 통해 객체 사본 암호화를 요청하려면 ObjectMetadata 속성을 사용하여 CopyObjectRequest에서 서버 측 암호화를 지정합니다.

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

객체를 업로드할 때 Amazon S3에 객체를 암호화하도록 지시할 수 있습니다. 기존 객체의 암호화 상태를 변경하기 위해서는 객체를 복사한 다음 원본 객체를 삭제합니다. 기본적으로 복사 작업은 대상 객체의 서버 측 암호화를 명시적으로 요청하는 경우에만 대상을 암호화합니다. CopyObjectRequest에서 SSE-S3를 지정하려면 다음을 추가합니다.

 ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256

객체를 복사하는 방법에 대한 실제 예제는 AWS SDK 사용를 참조하십시오.

다음은 객체를 업로드하는 예제입니다. 요청 시 이 예제는 Amazon S3에 객체를 암호화하도록 지시합니다. 그런 다음 객체 메타데이터를 검색해 사용된 암호화 방법을 확인합니다. 코드 예제 설정 및 실행에 대한 자세한 내용은 AWS SDK for .NET 개발자 안내서의 AWS SDK for .NET 시작하기를 참조하세요.

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

이 주제에서는 Amazon S3에 업로드하는 객체에 SSE-S3를 추가하기 위해 AWS SDK for PHP 버전 3의 클래스를 사용하는 방법을 보여줍니다. AWS SDK for Ruby API에 대한 자세한 내용은 AWS SDK for Ruby – 버전 2를 참조하세요.

Amazon S3에 객체를 업로드하려면 Aws\S3\S3Client::putObject() 메서드를 사용합니다. 업로드 요청에 x-amz-server-side-encryption 요청 헤더를 추가하려면 다음 코드 예제에 나와 있듯이 ServerSideEncryption 파라미터를 AES256 값으로 지정합니다. 서버 측 암호화 요청에 대한 자세한 정보는 REST API 사용 단원을 참조하십시오.

 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를 지정할 수 있습니다.

기존 객체의 암호화 상태를 확인하려면 다음 PHP 코드 예제에 나와 있듯이 Aws\S3\S3Client::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\S3\S3Client::copyObject() 메서드를 사용하여 객체를 복사하고 소스 객체를 삭제하십시오. ServerSideEncryption 파라미터를 AES256 값으로 사용하여 대상 객체의 서버 측 암호화를 명시적으로 요청하지 않는 한 기본적으로 copyObject()는 대상을 암호화하지 않습니다. 다음 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',
]);

자세한 정보는 다음 주제를 참조하세요.

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__