Angeben serverseitiger Verschlüsselung mit von Amazon S3 verwalteten Schlüsseln (SSE-S3)

Wenn Sie das verwenden, AWS SDK für Java um ein Objekt hochzuladen, können Sie SSE-S3 verwenden, um es zu verschlüsseln. Um eine serverseitige Verschlüsselung anzufordern, legen Sie mit der ObjectMetadata-Eigenschaft der PutObjectRequest den Anforderungs-Header x-amz-server-side-encryption fest. Wenn Sie die Methode putObject() des AmazonS3Client-Clients aufrufen, verschlüsselt und speichert Amazon S3 die Daten.

Sie können auch die Verschlüsselung mit SSE-S3 anfordern, wenn Sie Objekte mit der API-Operation für mehrteilige Uploads hochladen:

Sie können den Verschlüsselungsstatus eines Objekts (Verschlüsseln eines unverschlüsselten Objekts oder Entschlüsseln eines verschlüsselten Objekts) nicht direkt ändern. Um den Verschlüsselungsstatus eines Objekts zu ändern, erstellen Sie eine Kopie des Objekts, geben dabei den gewünschten Verschlüsselungsstatus der Kopie an und löschen dann das Originalobjekt. Amazon S3 verschlüsselt das kopierte Objekt nur, wenn Sie explizit eine serverseitige Verschlüsselung anfordern. Um die Verschlüsselung des kopierten Objekts über die Java-API anzufordern, geben Sie unter Verwendung der ObjectMetadata-Eigenschaft eine serverseitige Verschlüsselung in der CopyObjectRequest an.

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

Wenn Sie ein Objekt hochladen, können Sie Amazon S3 dazu anweisen, es zu verschlüsseln. Um den Verschlüsselungsstatus eines vorhandenen Objekts zu ändern, erstellen Sie eine Kopie des Objekts und löschen dann das Quellobjekt. Beachten Sie, dass die Kopieroperation das Ziel nur verschlüsselt, wenn Sie auf dem Zielobjekt ausdrücklich eine serverseitige Verschlüsselung anfordern. Fügen Sie Folgendes hinzu, um SSE-S3 in CopyObjectRequest anzugeben:

 ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256

Ein funktionierendes Beispiel, das zeigt, wie ein Objekt kopiert wird, finden Sie unter Unter Verwendung der AWS SDKs.

Das folgende Beispiel lädt ein Objekt hoch. In der Anfrage weist das Beispiel Amazon S3 dazu an, das Objekt zu verschlüsseln. Das Beispiel ruft dann Objekt-Metadaten ab und überprüft die verwendete Verschlüsselungsmethode. Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter Getting Started with the AWS SDK for .NET im AWS SDK for .NET Developer Guide.

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

Dieses Thema zeigt, wie Sie Klassen aus Version 3 von verwenden AWS SDK für PHP , um SSE-S3 zu Objekten hinzuzufügen, die Sie auf Amazon S3 hochladen. Weitere Informationen zum AWS SDK for Ruby API finden Sie unter AWS SDK for Ruby — Version 2.

Um ein Objekt zu Amazon S3 hochzuladen, verwenden Sie die Methode Aws\S3\S3Client::putObject(). Um Ihrer Upload-Anfrage den Anfrage-Header x-amz-server-side-encryption hinzuzufügen, geben Sie den Parameter ServerSideEncryption mit dem Wert AES256 an, wie im folgenden Codebeispiel veranschaulicht. Weitere Informationen zur serverseitigen Verschlüsselungsanforderungen finden Sie unter Verwenden der 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 gibt als Antwort den x-amz-server-side-encryption-Header mit dem Wert zurück, den der Verschlüsselungsalgorithmus für die Verschlüsselung Ihrer Objektdaten verwendet hat.

Wenn Sie große Objekte mithilfe der API-Operation für mehrteilige Uploads hochladen, können Sie wie folgt SSE-S3 für diese Objekte angeben:

Um den Verschlüsselungsstatus eines vorhandenen Objekts zu bestimmen, rufen Sie die Objektmetadaten mit der Methode Aws\S3\S3Client::headObject() ab, wie im folgenden PHP-Codebeispiel veranschaulicht.

 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'];

Um den Verschlüsselungsstatus eines vorhandenen Objekts zu ändern, erstellen Sie mittels der Methode Aws\S3\S3Client::copyObject() eine Kopie des Objekts und löschen dann das Quellobjekt. Standardmäßig verschlüsselt copyObject() das Ziel nicht, es sei denn, Sie fordern explizit die serverseitige Verschlüsselung des Zielobjekts an, indem Sie den Parameter ServerSideEncryption mit dem Wert AES256 angeben. Im folgenden PHP-Codebeispiel wird eine Kopie eines Objekts erstellt und dem kopierten Objekt eine serverseitige Verschlüsselung hinzugefügt.

 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',
]);

Weitere Informationen finden Sie unter den folgenden Themen:

Wenn Sie die AWS SDK für Ruby zum Hochladen eines Objekts verwenden, können Sie angeben, dass das Objekt im Ruhezustand mit SSE-S3 verschlüsselt gespeichert wird. Wenn Sie das Objekt zurücklesen, wird es automatisch entschlüsselt.

Das folgende Beispiel für AWS SDK für Ruby Version 3 zeigt, wie angegeben wird, dass eine auf Amazon S3 hochgeladene Datei im Ruhezustand verschlüsselt wird.

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__

Das folgende Beispiel zeigt, wie Sie den Verschlüsselungsstatus eines vorhandenen Objekts bestimmen.

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__

Wenn die serverseitige Verschlüsselung für das in Amazon S3 gespeicherte Objekt nicht verwendet wird, gibt die Methode null zurück.

Um den Verschlüsselungsstatus eines vorhandenen Objekts zu ändern, erstellen Sie eine Kopie des Objekts und löschen dann das Quellobjekt. Standardmäßig verschlüsseln die Methoden zum Kopieren das Ziel nicht, es sei denn, Sie fordern explizit die serverseitige Verschlüsselung an. Sie können die Verschlüsselung des Zielobjekts anfordern, indem Sie den Wert server_side_encryption im Hash-Argument der Option angeben, wie im folgenden Ruby-Codebeispiel gezeigt. Das Code-Beispiel zeigt, wie ein Objekt kopiert und die Kopie mit SSE-S3 verschlüsselt wird.

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__