- Java
-
Wenn Sie mit AWS SDK for Java ein Objekt hochladen, können Sie es mit SSE-S3 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:
-
Wenn Sie die High-Level-API-Operation für mehrteilige Uploads verwenden, wenden Sie mit der Methode TransferManager serverseitige Verschlüsselung auf Objekte an, während Sie sie hochladen. Sie können eine beliebige der Upload-Methoden nutzen, die ObjectMetadata als Parameter entgegennehmen. Weitere Informationen finden Sie unter Hochladen eines Objekts mit Multipart-Upload.
-
Wenn Sie die Low-Level-API-Operation für mehrteilige Uploads verwenden, legen Sie die serverseitige Verschlüsselung beim Initiieren des mehrteiligen Uploads fest. Sie fügen die Eigenschaft ObjectMetadata beim Aufruf der Methode InitiateMultipartUploadRequest.setObjectMetadata() hinzu. Weitere Informationen finden Sie unter Verwenden der AWS-SDKs (Low-Level-API).
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.
Beispiel
Das folgende Beispiel veranschaulicht, wie Sie die serverseitige Verschlüsselung unter Verwendung des AWS SDK for Java festlegen. Es veranschaulicht, wie Sie die folgenden Aufgaben ausführen:
-
Laden Sie ein neues Objekt mit SSE-S3 hoch.
-
Ändern des Verschlüsselungsstatus eines Objekts (in diesem Beispiel Verschlüsseln eines zuvor unverschlüsselten Objekts) durch Anfertigen einer Kopie des Objekts
-
Überprüfen des Verschlüsselungsstatus des Objekts
Weitere Informationen zur serverseitigen Verschlüsselung finden Sie unter Verwenden der REST-API. Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Testen der Java-Codebeispiele für Amazon S3.
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
-
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 Verwenden 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. Weitere Informationen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Ausführen der .NET-Codebeispiele für Amazon S3.
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
-
In diesem Thema wird veranschaulicht, wie Sie mithilfe von Klassen aus Version 3 des AWS SDK for PHP Objekten, die Sie auf Amazon S3 hochladen, SSE-S3 hinzuzufügen. Es wird vorausgesetzt, dass Sie den Anleitungen für Verwenden von AWS SDK for PHP und Ausführen von PHP-Beispielen folgen und der AWS SDK for PHP ordnungsgemäß installiert ist.
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:
-
Wenn Sie die Low-Level-API-Operation für mehrteilige Uploads verwenden, geben Sie die serverseitige Verschlüsselung beim Aufruf der Methode Aws\S3\S3Client::createMultipartUpload() an. Um Ihrer Upload-Anfrage den Anfrage-Header x-amz-server-side-encryption hinzuzufügen, geben Sie für den Parameter array den ServerSideEncryption-Schlüssel mit dem Wert AES256 an. Weitere Informationen zur Low-Level-API-Operation für mehrteilige Uploads finden Sie unter Verwenden der AWS-SDKs (Low-Level-API).
-
Wenn Sie die High-Level-API-Operation für mehrteilige Uploads verwenden, geben Sie die serverseitige Verschlüsselung mittels des Parameters ServerSideEncryption der API-Operation CreateMultipartUpload an. Ein Beispiel für die Verwendung der Methode setOption() mit der High-Level-API-Operation für mehrteilige Uploads finden Sie unter Hochladen eines Objekts mit Multipart-Upload.
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:
- Ruby
-
Beim Hochladen eines Objekts mit AWS SDK for Ruby können Sie festlegen, dass das Objekt im Ruhezustand mit SSE-S3 verschlüsselt gespeichert werden soll. Wenn Sie das Objekt zurücklesen, wird es automatisch entschlüsselt.
Das folgende Beispiel mit AWS SDK for Ruby Version 3 zeigt, wie festgelegt wird, dass eine auf Amazon S3 hochgeladene Datei im Ruhezustand verschlüsselt werden soll.
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
def run_demo
bucket_name = "doc-example-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 get_object
@object.get
rescue Aws::Errors::ServiceError => e
puts "Couldn't get object #{@object.key}. Here's why: #{e.message}"
end
end
# Replace bucket name and object key with an existing bucket and object that you own.
def run_demo
bucket_name = "doc-example-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
# Replace the source and target bucket names with existing buckets you own and replace the source object key
# with an existing object in the source bucket.
def run_demo
source_bucket_name = "doc-example-bucket1"
source_key = "my-source-file.txt"
target_bucket_name = "doc-example-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__
