Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Verwenden Sie serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (-C) SSE
Die serverseitige Verschlüsselung dient zum Schutz ruhender Daten. Die serverseitige Verschlüsselung verschlüsselt nur die Objektdaten, nicht die Metadaten des Objekts. Durch die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) können Sie Ihre Daten mit Ihren eigenen Verschlüsselungsschlüsseln verschlüsselt speichern. Mit dem Verschlüsselungsschlüssel, den Sie als Teil Ihrer Anforderung bereitstellen, verwaltet Amazon S3 die Datenverschlüsselung, wenn es auf Datenträger schreibt, und die Entschlüsselung, wenn Sie auf Ihre Objekte zugreifen. Sie müssen also für die Datenverschlüsselung und -entschlüsselung keinen Code mehr verwalten. Sie müssen nur noch die von Ihnen bereitgestellten Verschlüsselungsschlüssel verwalten.
Wenn Sie ein Objekt hochladen, verwendet Amazon S3 den von Ihnen angegebenen Verschlüsselungsschlüssel, um die AES 256-Verschlüsselung auf Ihre Daten anzuwenden. Amazon S3 entfernt dann den Verschlüsselungsschlüssel aus dem Speicher. Wenn Sie ein Objekt abrufen, müssen Sie denselben Verschlüsselungsschlüssel als Teil Ihrer Anfrage angeben. Amazon S3 überprüft zuerst, ob der von Ihnen bereitgestellte Verschlüsselungsschlüssel übereinstimmt, und entschlüsselt das Objekt, bevor Objektdaten zurückgegeben werden.
Für die Verwendung von SSE -C fallen keine zusätzlichen Gebühren an. Für Anfragen zur Konfiguration und Verwendung von SSE -C fallen jedoch Standardgebühren für Amazon S3 S3-Anfragen an. Informationen zu Preisen finden Sie unter Amazon S3 – Preise.
Amazon S3 speichert den von Ihnen bereitgestellten Verschlüsselungsschlüssel nicht. Stattdessen wird ein zufällig gesalzener Hash-basierter Message Authentication Code (HMAC) -Wert des Verschlüsselungsschlüssels gespeichert, um future Anfragen zu validieren. Der gesalzene HMAC Wert kann nicht verwendet werden, um den Wert des Verschlüsselungsschlüssels abzuleiten oder den Inhalt des verschlüsselten Objekts zu entschlüsseln. Das bedeutet, wenn Sie den Verschlüsselungsschlüssel verlieren, verlieren Sie das Objekt.
Die S3-Replikation unterstützt Objekte, die mit SSE -C verschlüsselt sind. Weitere Hinweise zur Replikation verschlüsselter Objekte finden Sie unter. Replikation verschlüsselter Objekte (SSE-S3, SSE -, DSSE - KMSKMS, SSE -C)
Weitere Informationen zu SSE -C finden Sie in den folgenden Themen.
SSE-C im Überblick
Dieser Abschnitt bietet einen Überblick über SSE -C. Beachten Sie bei der Verwendung von SSE -C die folgenden Überlegungen.
-
Sie müssen HTTPS verwenden.
Amazon S3 lehnt alle Anfragen ab, die HTTP bei Verwendung von SSE -C gestellt werden. Aus Sicherheitsgründen empfehlen wir, dass Sie jeden Schlüssel, den Sie irrtümlich versenden, als HTTP kompromittiert betrachten. Verwerfen Sie den Schlüssel und rotieren Sie ihn wie erforderlich.
-
Das Entity-Tag (ETag) in der Antwort ist nicht der MD5 Hash der Objektdaten.
-
Sie Verwalten ein Mapping, welcher Verschlüsselungsschlüssel für die Verschlüsselung welches Objekts verwendet wurde. Amazon S3 speichert keine Verschlüsselungsschlüssel. Sie sind dafür verantwortlich, zu verwalten, welchen Verschlüsselungsschlüssel Sie für welches Objekt angegeben haben.
-
Wenn für Ihren Bucket Versioning aktiviert ist, kann jede Objektversion, die Sie mit dieser Funktion hochladen, einen eigenen Verschlüsselungsschlüssel haben. Sie sind dafür verantwortlich, zu verwalten, welcher Verschlüsselungsschlüssel für welche Objektversion verwendet wurde.
-
Sie verwalten die Verschlüsselungsschlüssel auf der Clientseite, deshalb verwalten Sie auch alle zusätzlichen Sicherungsmechanismen auf der Clientseite, wie beispielsweise die Schlüsselrotation.
Wenn Sie den Verschlüsselungsschlüssel verlieren, schlagen alle GET-Anfragen für ein Objekt ohne seinen Verschlüsselungsschlüssel fehl und Sie verlieren das Objekt.
-C erforderlich und einschränkend SSE
Um SSE -C für alle Objekte in einem bestimmten Amazon S3 S3-Bucket zu verlangen, können Sie eine Bucket-Richtlinie verwenden.
Die folgende Bucket-Richtlinie verweigert beispielsweise Upload object (s3:PutObject) -Berechtigungen für alle Anfragen, die nicht den x-amz-server-side-encryption-customer-algorithm Header enthalten, der -C anfordertSSE.
{
"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"
}
}
}
]
}
Sie können auch eine Richtlinie verwenden, um die serverseitige Verschlüsselung aller Objekte in einem bestimmten Amazon-S3-Bucket einzuschränken. Die folgende Bucket-Richtlinie verweigert beispielsweise allen Benutzern die Berechtigung zum Hochladen von Objekten (s3:PutObject), wenn die Anfrage den x-amz-server-side-encryption-customer-algorithm Header enthält, der -C anfordert. SSE
{
"Version": "2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "RestrictSSECObjectUploads",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"Null": {
"s3:x-amz-server-side-encryption-customer-algorithm": "false"
}
}
}
]
}
Wenn Sie eine Bucket-Richtlinie verwenden, bei der die Option SSE -C aktiviert werden musss3:PutObject, müssen Sie den x-amz-server-side-encryption-customer-algorithm Header in alle mehrteiligen Upload-Anfragen (CreateMultipartUpload, UploadPart und) aufnehmen. CompleteMultipartUpload
Vorsigniert und URLs -C SSE
Sie können ein vorsigniertes Objekt generierenURL, das für Operationen wie das Hochladen eines neuen Objekts, das Abrufen eines vorhandenen Objekts oder das Abrufen von Objektmetadaten verwendet werden kann. Vorsignierte unterstützen URLs -C wie folgt: SSE
-
Wenn Sie eine vorsignierte Datei erstellenURL, müssen Sie den Algorithmus angeben, indem Sie den x-amz-server-side-encryption-customer-algorithm Header in der Signaturberechnung verwenden.
-
Wenn Sie Presigned verwenden, URL um ein neues Objekt hochzuladen, ein vorhandenes Objekt abzurufen oder nur Objektmetadaten abzurufen, müssen Sie alle Verschlüsselungsheader in der Anfrage Ihrer Client-Anwendung angeben.
Für non-SSE-C Objekte können Sie ein vorsigniertes Objekt generieren URL und dieses direkt URL in einen Browser einfügen, um auf die Daten zuzugreifen.
Bei SSE -C-Objekten ist dies jedoch nicht möglich, da Sie zusätzlich zu den vorsignierten Objekten auch HTTP Header angeben müssenURL, die für -C-Objekte spezifisch sind. SSE Daher können Sie vorsignierte Objekte nur programmgesteuert URLs für SSE -C-Objekte verwenden.
Weitere Hinweise zu presigned finden Sie unter. URLs Laden Sie Objekte mit vorsignierten Objekten herunter und laden Sie sie hoch URLs
Angeben der serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (-C) SSE
Bei der Objekterstellung mit dem können Sie die REST API serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) angeben. Wenn Sie SSE -C verwenden, müssen Sie die Informationen zum Verschlüsselungsschlüssel mithilfe der folgenden Anforderungsheader angeben.
| Name |
Beschreibung |
x-amz-server-side-encryption-customer-algorithm
|
Verwenden Sie diesen Header, um den Verschlüsselungsalgorithmus anzugeben. Der Header-Wert muss AES256 sein.
|
x-amz-server-side-encryption-customer-key
|
Verwenden Sie diesen Header, um den base64-codierten 256-bit-Verschlüsselungsschlüssel für Amazon S3 bereitzustellen, mit dem Ihre Daten verschlüsselt und entschlüsselt werden.
|
x-amz-server-side-encryption-customer-key-MD5
|
Verwenden Sie diesen Header, um den Base64-codierten MD5 128-Bit-Digest des Verschlüsselungsschlüssels gemäß 1321 bereitzustellen. RFC Amazon S3 verwendet diesen Header für eine Überprüfung der Nachrichtenintegrität, um sicherzustellen, dass der Verschlüsselungsschlüssel fehlerfrei übertragen wurde.
|
Sie können AWS SDK Wrapper-Bibliotheken verwenden, um diese Header zu Ihrer Anfrage hinzuzufügen. Bei Bedarf können Sie die Amazon S3 REST API S3-Aufrufe direkt in Ihrer Anwendung tätigen.
Sie können die Amazon S3 S3-Konsole nicht verwenden, um ein Objekt hochzuladen und SSE -C anzufordern. Sie können die Konsole auch nicht verwenden, um ein vorhandenes Objekt, das mit SSE -C gespeichert wurde, zu aktualisieren (z. B. die Speicherklasse zu ändern oder Metadaten hinzuzufügen).
Amazon S3 S3-RestAPIs, der SSE -C unterstützt
Die folgenden Amazon S3 APIs unterstützen serverseitige Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln (SSE-C).
-
GETVorgang — Beim Abrufen von Objekten mithilfe von GET API (siehe GETObjekt) können Sie die Anforderungsheader angeben.
-
HEADOperation — Um Objektmetadaten mithilfe von HEAD API (siehe HEADObjekt) abzurufen, können Sie diese Anforderungsheader angeben.
-
PUTOperation — Beim Hochladen von Daten mithilfe des PUT Objekts API (siehe PUTObjekt) können Sie diese Anforderungsheader angeben.
-
Mehrteiliger Upload — Wenn Sie große Objekte mithilfe des mehrteiligen Uploads hochladenAPI, können Sie diese Header angeben. Sie geben diese Header in der Initiierungsanforderung (siehe Initiieren mehrteiliger Uploads) und in jeder nachfolgenden Anforderung für einen Teil-Upload an (siehe Hochladen von Teilen oder Hochladen von Teilen – Kopieren). Für jede teilweise Upload-Anfrage muss dieselbe Verschlüsslungsinformation angegeben werden, wie diejenige, die Sie in der Initiierungsanfrage für den mehrteiligen Upload angegeben haben.
-
POSTOperation — Wenn Sie einen POST Vorgang zum Hochladen eines Objekts (siehe POSTObjekt) verwenden, geben Sie anstelle der Anforderungsheader dieselben Informationen in die Formularfelder ein.
-
Kopiervorgang — Wenn Sie ein Objekt kopieren (siehe PUTObjekt — Kopieren), haben Sie sowohl ein Quell- als auch ein Zielobjekt:
-
Wenn Sie möchten, dass das Zielobjekt serverseitig mit AWS verwalteten Schlüsseln verschlüsselt wird, müssen Sie den x-amz-server-side-encryption Anforderungsheader angeben.
-
Wenn Sie möchten, dass das Zielobjekt mit SSE -C verschlüsselt wird, müssen Sie Verschlüsselungsinformationen mithilfe der drei in der vorherigen Tabelle beschriebenen Header angeben.
-
Wenn das Quellobjekt mit SSE -C verschlüsselt ist, müssen Sie die Informationen zum Verschlüsselungsschlüssel mithilfe der folgenden Header angeben, damit Amazon S3 das Objekt zum Kopieren entschlüsseln kann.
| Name |
Beschreibung |
x-amz-copy-source-server-side-encryption-customer-algorithm
|
Verwenden Sie diesen Header, um den Verschlüsselungsalgorithmus anzugeben, den Amazon S3 für die Entschlüsselung des Quellobjekts verwenden soll. Dieser Wert muss AES256 lauten.
|
|
x-amz-copy-source-server-side-encryption-customer-key
|
Verwenden Sie diesen Header, um den base64-codierten 256-bit-Verschlüsselungsschlüssel für Amazon S3 bereitzustellen, mit dem das Quellobjekt entschlüsselt werden soll. Dieser Verschlüsselungsschlüssel muss derjenige sein, den Sie Amazon S3 beim Erstellen des Quellobjekts bereitgestellt haben. Andernfalls kann Amazon S3 das Objekt nicht entschlüsseln.
|
x-amz-copy-source-server-side-encryption-customer-key-MD5
|
Fügen Sie diesen Header hinzu, um den Base64-codierten MD5 128-Bit-Digest des Verschlüsselungsschlüssels gemäß 1321 bereitzustellen. RFC
|
Die folgenden Beispiele zeigen, wie eine serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) für Objekte angefordert wird. Dabei werden folgende Vorgänge ausgeführt. Jeder Vorgang zeigt, wie SSE-C-related Header in der Anfrage angegeben werden:
-
Put object – Lädt ein Objekt hoch und fordert die serverseitige Verschlüsselung mit einem vom Kunden bereitgestellten Verschlüsselungsschlüssel an.
-
Get object – Lädt das im vorigen Schritt hochgeladene Objekt herunter. Sie stellen in der Anforderung dieselben Verschlüsselungs-Informationen bereit, die Sie beim Hochladen des Objekts angegeben haben. Amazon S3 benötigt diese Informationen, um das Objekt zu entschlüsseln und an Sie zurückzugeben.
-
Get object metadata – Ruft die Metadaten des Objekts ab. Sie stellen dieselben Verschlüsselungs-Informationen bereit, die beim Erstellen des Objekts verwendet wurden.
-
Copy object – Erstellt eine Kopie des zuvor hochgeladenen Objekts. Da das Quellobjekt mit SSE -C gespeichert wird, müssen Sie seine Verschlüsselungsinformationen in Ihrer Kopieranforderung angeben. Standardmäßig verschlüsselt Amazon S3 die Kopie des Objekts nur, wenn Sie dies ausdrücklich anfordern. In diesem Beispiel wird Amazon S3 dazu angewiesen, eine verschlüsselte Kopie des Objekts zu speichern.
- Java
-
Dieses Beispiel zeigt, wie ein Objekt in einer einzigen Operation hochgeladen wird. Wenn Sie den Multipart Upload verwenden, API um große Objekte hochzuladen, geben Sie die Verschlüsselungsinformationen auf die gleiche Weise ein, wie in diesem Beispiel gezeigt. Beispiele für mehrteilige Uploads, bei denen das verwendet wird, finden Sie unter AWS SDK for Java. Hochladen eines Objekts mit Multipart-Upload
Um die erforderlichen Verschlüsselungsinformationen hinzuzufügen, schließen Sie in Ihre Anfrage einen SSECustomerKey ein. Weitere Informationen zur SSECustomerKey Klasse finden Sie im REST API Abschnitt.
Hinweise zu SSE -C finden Sie unterVerwenden Sie serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (-C) SSE. Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter Erste Schritte im AWS SDK for Java Entwicklerhandbuch.
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
-
Hinweise zu SSE -C finden Sie unter. Verwenden Sie serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (-C) SSE Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter Erste Schritte mit dem AWS SDK for. NETim AWS SDKfür. NETLeitfaden für Entwickler.
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<PutObjectRequest> 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);
}
}
}
Das Beispiel im vorherigen Abschnitt zeigt, wie Sie bei den Vorgängen,, Head und Copy eine serverseitige Verschlüsselung mit einem vom Kunden bereitgestellten Schlüssel (SSE-C) anfordern. PUT GET In diesem Abschnitt werden andere Amazon S3 beschriebenAPIs, die SSE -C unterstützen.
- Java
-
Um große Objekte hochzuladen, können Sie den mehrteiligen Upload verwenden API (sieheHochladen und Kopieren von Objekten mit mehrteiligen Uploads). APIsUm große Objekte hochzuladen, können Sie entweder High-Level oder Low-Level verwenden. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anfrage.
-
Wenn Sie den High-Level verwenden TransferManagerAPI, geben Sie die verschlüsselungsspezifischen Header in der an (siehe). PutObjectRequest Hochladen eines Objekts mit Multipart-Upload
-
Wenn Sie den Low-Level-Modus verwendenAPI, geben Sie verschlüsselungsbezogene Informationen in den einInitiateMultipartUploadRequest, gefolgt von identischen Verschlüsselungsinformationen in jedem. UploadPartRequest In Ihrer CompleteMultipartUploadRequest müssen Sie keine verschlüsselungsspezifischen Header angeben. Beispiele finden Sie unter Unter Verwendung von AWS SDKs (APILow-Level).
Das folgende Beispiel dient der Erstellung von Objekten und zeigtTransferManager, wie Informationen im Zusammenhang mit SSE -C bereitgestellt werden. Das Beispiel erledigt Folgendes:
-
Erstellt ein Objekts mit der Methode TransferManager.upload(). In der Instance PutObjectRequest geben Sie anzufordernde Verschlüsselungsschlüssel-Informationen an. Amazon S3 verschlüsselt das Objekt mit dem vom Kunden bereitgestellten Schüssel.
-
Erstellt eine Kopie des Objekts durch Aufrufen der TransferManager.copy()-Methode. Das Beispiel weist Amazon S3 dazu an, eine Objektkopie unter Verwendung eines neuen SSECustomerKey zu verschlüsseln. Da das Quellobjekt mit SSE -C verschlüsselt ist, stellt der CopyObjectRequest auch den Verschlüsselungsschlüssel des Quellobjekts bereit, sodass Amazon S3 das Objekt vor dem Kopieren entschlüsseln kann.
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
-
Um große Objekte hochzuladen, können Sie den mehrteiligen Upload verwenden API (siehe). Hochladen und Kopieren von Objekten mit mehrteiligen Uploads AWS SDKfür. NETermöglicht das Hochladen großer Objekte sowohl auf hoher als auch APIs auf niedriger Ebene. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anfrage.
-
Wenn Sie High-Level verwenden Transfer-Utility API, geben Sie die verschlüsselungsspezifischen Header in der Abbildung an. TransferUtilityUploadRequest Codebeispiele finden Sie unter Hochladen eines Objekts mit Multipart-Upload.
TransferUtilityUploadRequest request = new TransferUtilityUploadRequest()
{
FilePath = filePath,
BucketName = existingBucketName,
Key = keyName,
// Provide encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
-
Bei Verwendung der Low-Level-Methode API geben Sie Informationen zur Verschlüsselung in der Anfrage zur Initiierung eines mehrteiligen Uploads ein, gefolgt von identischen Verschlüsselungsinformationen in den nachfolgenden Upload-Teilanforderungen. In der vollständigen Anforderung zum mehrteiligen Upload müssen Sie keine verschlüsselungsspezifischen Header angeben. Beispiele finden Sie unter Unter Verwendung von AWS SDKs (APILow-Level).
Nachfolgend finden Sie ein Beispiel für einen mehrteiligen Low-Level-Upload, der eine Kopie eines vorhandenen großen Objekts erstellt. In dem Beispiel wird das zu kopierende Objekt mit SSE -C in Amazon S3 gespeichert, und Sie möchten das Zielobjekt auch mit SSE -C speichern. In dem Beispiel gehen Sie wie folgt vor:
-
Initiieren Sie eine mehrteilige Upload-Anfrage, indem Sie einen Verschlüsselungsschlüssel und zugehörige Informationen bereitstellen.
-
Stellen Sie Verschlüsselungsschlüssel für das Quell- und das Zielobjekt sowie die zugehörigen Informationen in der CopyPartRequest bereit.
-
Ermitteln Sie die Größe des zu kopierenden Quellobjekts, indem Sie die Objekt-Metadaten abrufen.
-
Laden Sie die Objekte in Teilen mit je 5 MB hoch.
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<CopyPartResponse> uploadResponses = new List<CopyPartResponse>();
// 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<UploadPartResponse> uploadResponses = new List<UploadPartResponse>();
// 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<PartETag>(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);
}
}
}
}
