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. # Angabe der serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln () SSE-C Server-side Die Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) ist für neue Allzweck-Buckets standardmäßig deaktiviert. Bevor Sie Objekte mit hochladen können SSE-C, müssen Sie sie aktivieren, indem Sie `NONE` in der Standardverschlüsselungskonfiguration Ihres Buckets `BlockedEncryptionTypes` auf einstellen. Weitere Informationen finden Sie unter [Sperren oder Entsperren SSE-C für einen Allzweck-Bucket](blocking-unblocking-s3-c-encryption-gpb.md). Sobald SSE-C es für Ihren Bucket aktiviert ist, können Sie es SSE-C in Ihren Upload-Anfragen verwenden, indem Sie die erforderlichen Header übergeben. Sehen Sie [Amazon S3 S3-Aktionen, die das Schreiben von Daten unterstützen mit SSE-C](#amazon-s3-actions-that-support-writing-data-with-sse-c) sich das an und stellen Sie sicher, dass Sie das [S3-API-Header sind für Anfragen zur SSE-C Objektverschlüsselung und -entschlüsselung erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests) angeben. Wenn Sie ein bestimmtes Objekt hochladen SSE-C, verwendet Amazon S3 den von Ihnen angegebenen Verschlüsselungsschlüssel, um Ihre Daten zu AES-256 verschlüsseln. 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. Stellen Sie vor der Verwendung sicher SSE-C, dass Sie die überprüft haben[Überlegungen vor der Verwendung SSE-C](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c). **Anmerkung** Amazon S3 speichert den von Ihnen bereitgestellten Verschlüsselungsschlüssel nicht. Stattdessen wird ein zufällig gesalzener HMAC-Wert ( Hash-based Message Authentication Code) des Verschlüsselungsschlüssels gespeichert, um future Anfragen zu validieren. Der mit einem Salt versehene 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. **Topics** + [SSE-C Aktionen und erforderliche Header](#sse-c-actions-and-required-headers) + [Beispiel für SSE-C eine Bucket-Richtlinie zur Durchsetzung der Verschlüsselung](#example-bucket-policy-to-enforce-sse-c-encryption) + [Vorsignierte URLs und SSE-C](#ssec-and-presignedurl) + [Anfragen stellen mit SSE-C](#making-requests-with-sse-c) + [Verwenden der REST-API](#using-rest-api-sse-c) + [Verwendung der AWS SDKs, die SSE-C für PUT-, GET-, Head- und Copy-Operationen spezifiziert werden sollen](#sse-c-using-sdks) + [Verwendung der AWS SDKs, die SSE-C für mehrteilige Uploads angegeben werden müssen](#sse-c-using-sdks-multipart-uploads) ## SSE-C Aktionen und erforderliche Header Die Angabe SSE-C unterstützter S3-APIs erfordert die Übergabe bestimmter Anforderungsparameter. **Anmerkung** Die `PutBucketEncryption` API unterstützt die Einstellung SSE-C als Standardverschlüsselungsmethode für einen Bucket nicht, Objekte werden nicht automatisch verwendet SSE-C. SSE-C ist eine Verschlüsselungsmethode auf Objektebene, bei der Sie den Verschlüsselungsschlüssel bei jeder Upload- oder Download-Anfrage angeben. Amazon S3 verwendet diesen Schlüssel, um das Objekt während der Anfrage zu verschlüsseln oder zu entschlüsseln, und verwirft dann den Schlüssel. Sie steuern jedoch über `PutBucketEncryption` den Parameter, ob SSE-C Uploads für den Bucket zulässig sind. `BlockedEncryptionTypes` Standardmäßig sind neue Buckets SSE-C blockiert. Sie müssen auf einstellen, `BlockedEncryptionTypes` um Uploads `NONE` zuzulassen SSE-C . ### Amazon S3 S3-Aktionen, die das Schreiben von Daten unterstützen mit SSE-C Sie können serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) anfordern, wenn Sie Objekte in einen Allzweck-Bucket schreiben, indem Sie die folgenden API-Operationen oder -Aktionen verwenden: + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html) + [https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html) **Anmerkung** Die S3-Replikation unterstützt Objekte, die mit SSE-C verschlüsselt sind. Weitere Informationen zum Replizieren verschlüsselter Objekte finden Sie unter[Verschlüsselte Objekte replizieren (SSE-S3, SSE-KMS, DSSE-KMS, SSE-C)](replication-config-for-kms-objects.md). ### S3-API-Header sind für Anfragen zur SSE-C Objektverschlüsselung und -entschlüsselung erforderlich Sie müssen die folgenden drei API-Header angeben, um Objekte zu verschlüsseln oder zu entschlüsseln: SSE-C + `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 bereitzustellen, den Amazon S3 zum Verschlüsseln oder Entschlüsseln Ihrer Daten verwenden kann. + `x-amz-server-side-encryption-customer-key-MD5`Verwenden Sie diesen Header, um den Base64-codierten 128-Bit-MD5-Digest des Verschlüsselungsschlüssels gemäß RFC 1321 bereitzustellen. Amazon S3 verwendet diesen Header für eine Überprüfung der Nachrichtenintegrität, um sicherzustellen, dass der Verschlüsselungsschlüssel fehlerfrei übertragen wurde. ### S3-API-Header sind für Anfragen zum Kopieren von Quellobjekten erforderlich, die verschlüsselt sind mit SSE-C Sie müssen die folgenden drei API-Header angeben, um verschlüsselte Quellobjekte zu kopieren: SSE-C + `x-amz-copy-source-server-side-encryption-customer-algorithm`Fügen Sie diesen Header hinzu, um den Algorithmus anzugeben, den Amazon S3 zum Entschlüsseln des Quellobjekts verwenden soll. Dieser Wert muss AES256 sein. + `x-amz-copy-source-server-side-encryption-customer-key`Fügen Sie diesen Header hinzu, um den Base64-codierten Verschlüsselungsschlüssel bereitzustellen, den Amazon S3 zum Entschlüsseln des Quellobjekts verwenden kann. 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 128-Bit-MD5-Digest des Verschlüsselungsschlüssels gemäß RFC 1321 bereitzustellen. ## Beispiel für SSE-C eine Bucket-Richtlinie zur Durchsetzung der Verschlüsselung Um SSE-C für alle Objekte, die in einen Amazon S3 S3-Bucket geschrieben wurden, vorzuschreiben, können Sie eine Bucket-Richtlinie verwenden. Die folgende Bucket-Richtlinie verweigert beispielsweise die Berechtigungen zum Hochladen von Objekten (`s3:PutObject`) für alle Anfragen, die nicht die `x-amz-server-side-encryption-customer-algorithm` Header-Anfrage SSE-C enthalten. ``` { "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" } } } ] } ``` **Wichtig** Wenn Sie eine Bucket-Richtlinie verwenden, die ein erfordert SSE-C `s3:PutObject`, müssen Sie den `x-amz-server-side-encryption-customer-algorithm` Header in alle mehrteiligen Upload-Anfragen (CreateMultipartUpload UploadPart, und CompleteMultipartUpload) aufnehmen. ## Vorsignierte URLs und SSE-C Sie können eine vorsignierte URL erstellen, die für Operationen wie das Hochladen eines neuen Objekts, das Abrufen eines vorhandenen Objekts oder von Objekt-Metadaten verwendet werden kann. Vorsignierte URLs unterstützen Folgendes SSE-C : + Beim Erstellen einer vorsignierten URL müssen Sie den Algorithmus unter Verwendung des `x-amz-server-side-encryption-customer-algorithm`-Headers in der Signaturberechnung angeben. + Wenn Sie die vorsignierte URL verwenden, um ein neues Objekt hochzuladen, ein vorhandenes Objekt abzurufen oder nur Objekt-Metadaten abzurufen, müssen Sie in der Anforderung Ihrer Client-Anwendung alle Verschlüsselungs-Header angeben. **Anmerkung** Für Objekte, die keine SSE-C Objekte sind, können Sie eine vorsignierte URL generieren und diese URL direkt in einen Browser einfügen, um auf die Daten zuzugreifen. Für SSE-C Objekte ist dies jedoch nicht möglich, da Sie zusätzlich zur vorsignierten URL auch objektspezifische HTTP-Header angeben müssen. SSE-C Daher können Sie vorsignierte URLs für SSE-C Objekte nur programmgesteuert verwenden. Weitere Informationen zu vorsignierten URLs finden Sie unter [Herunterladen und Hochladen von Objekten mit vorsignierten URLs](using-presigned-url.md). ## Anfragen stellen mit SSE-C Bei der Objekterstellung mit der REST-API können Sie die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln () angeben. SSE-C Wenn Sie verwenden SSE-C, müssen Sie Informationen zum Verschlüsselungsschlüssel mithilfe von angeben. [S3-API-Header sind für Anfragen zum Kopieren von Quellobjekten erforderlich, die verschlüsselt sind mit SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) Sie können AWS SDK-Wrapper-Bibliotheken verwenden, um diese Header zu Ihrer Anfrage hinzuzufügen. Falls nötig, können Sie auch die REST-API-Aufrufe in Amazon S3 direkt von Ihrer Anwendung aus durchführen. **Wichtig** SSE-C ist standardmäßig für alle neuen Buckets deaktiviert. Bevor Sie Objekte mit hochladen SSE-C, müssen Sie es aktivieren, indem Sie die Standardverschlüsselungskonfiguration Ihres Buckets aktualisieren. Weitere Informationen finden Sie unter [Sperren oder Entsperren SSE-C für einen Allzweck-Bucket](blocking-unblocking-s3-c-encryption-gpb.md). **Anmerkung** Sie können die Amazon S3 S3-Konsole nicht verwenden, um ein Objekt und eine Anfrage hochzuladen SSE-C. Sie können die Konsole auch nicht verwenden, um ein vorhandenes Objekt, das mit gespeichert wurde, zu aktualisieren (z. B. die Speicherklasse zu ändern oder Metadaten hinzuzufügen) SSE-C. Weitere Informationen finden Sie unter [S3-API-Header sind für Anfragen zur SSE-C Objektverschlüsselung und -entschlüsselung erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests). ## Verwenden der REST-API ### Amazon S3 S3-REST-APIs, die unterstützen SSE-C Die folgenden Amazon S3 S3-APIs unterstützen serverseitige Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln ()SSE-C. + **GET-Operation** – Sie können beim Abrufen von Objekten über die GET-API (siehe [GET Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)) die Anforderungs-Header angeben. + **HEAD-Operation** – Um Objektmetadaten über die HEAD-API abzurufen (siehe [HEAD Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)), können Sie diese Anforderungs-Header angeben. + **Operation PUT**: Sie können beim Hochladen von Daten über die PUT Object API (siehe [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)) diese Anforderungs-Header angeben. + **Multipart Upload** – Sie können beim Hochladen großer Objekte über die Multipart Upload-API diese Header angeben. [Sie geben diese Header in der Initiierungsanforderung (siehe [Mehrteiligen Upload initiieren](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)) und jeder nachfolgenden Teil-Upload-Anfrage (siehe Teil hochladen oder) an. [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html) 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. + **POST-Operation** – Bei Verwendung einer POST-Operation zum Hochladen eines Objekts (siehe [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)) geben Sie die Informationen in den Formularfeldern und nicht in den Anforderungs-Headern an. + **Kopiervorgang** — Wenn Sie ein Objekt kopieren (siehe [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)), haben Sie sowohl ein Quell- als auch ein Zielobjekt: + Wenn Sie den Verschlüsselungstyp des Zielobjekts angeben möchten, müssen Sie den `x-amz-server-side-encryption ` Anforderungsheader angeben. + Wenn Sie möchten, dass das Zielobjekt mit verschlüsselt wird SSE-C, müssen Sie Verschlüsselungsinformationen mithilfe der S3-API angeben[S3-API-Header sind für Anfragen zur SSE-C Objektverschlüsselung und -entschlüsselung erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests). + Wenn das Quellobjekt mit verschlüsselt ist SSE-C, müssen Sie die Informationen zum Verschlüsselungsschlüssel mithilfe der S3-API-Header [S3-API-Header sind für Anfragen zum Kopieren von Quellobjekten erforderlich, die verschlüsselt sind mit SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) angeben. ## Verwendung der AWS SDKs, die SSE-C für PUT-, GET-, Head- und Copy-Operationen spezifiziert werden sollen 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 gespeichert wird SSE-C, 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 ] **Anmerkung** Dieses Beispiel zeigt, wie ein Objekt in einer einzigen Operation hochgeladen wird. Wenn Sie die API für mehrteilige Uploads verwenden, um große Objekte hochzuladen, geben Sie Verschlüsslungsinformationen genauso wie in diesem Beispiel veranschaulicht ein. Beispiele für mehrteilige Uploads, bei denen das verwendet wird AWS SDK für Java, finden Sie unter. [Hochladen eines Objekts mit Multipart-Upload](mpu-upload-object.md) Um die erforderlichen Verschlüsselungsinformationen hinzuzufügen, schließen Sie in Ihre Anfrage einen `SSECustomerKey` ein. Weitere Informationen zur Klasse `SSECustomerKey` finden Sie im Abschnitt "REST API". Anweisungen zum Erstellen und Testen eines funktionierenden Beispiels finden Sie unter [Erste Schritte](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) im AWS SDK für Java Entwicklerhandbuch. **Example** ``` 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 ] **Anmerkung** Beispiele für das Hochladen großer Objekte mithilfe der API für mehrteilige Uploads finden Sie unter [Hochladen eines Objekts mit Multipart-Upload](mpu-upload-object.md) und [Verwendung der AWS SDKs (Low-Level-API)](mpu-upload-object.md#mpu-upload-low-level). Informationen zum Einrichten und Ausführen der Codebeispiele finden Sie unter [Getting Started with the AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) im *AWS SDK for .NET Developer Guide*. **Example** ``` 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 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); } } } ``` ------ ## Verwendung der AWS SDKs, die SSE-C für mehrteilige Uploads angegeben werden müssen Das Beispiel im vorherigen Abschnitt zeigt, wie bei den Vorgängen PUT, GET, Head und Copy eine serverseitige Verschlüsselung mit dem vom Kunden bereitgestellten Schlüssel (SSE-C) angefordert wird. In diesem Abschnitt werden andere Amazon S3 S3-APIs beschrieben, die Unterstützung bieten SSE-C. ------ #### [ Java ] Um große Objekte hochzuladen, können Sie mehrteilige Upload-APIs verwenden. Weitere Informationen finden Sie unter [Hochladen und Kopieren von Objekten mit mehrteiligen Uploads in Amazon S3](mpuoverview.md). Sie können entweder High-Level- und Low-Level-APIs zum Hochladen großer Objekte verwenden. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anforderung. + Wenn Sie die `TransferManager` High-Level-API verwenden, geben Sie die verschlüsselungsspezifischen Header in der an. `PutObjectRequest` Weitere Informationen finden Sie unter [Hochladen eines Objekts mit Multipart-Upload](mpu-upload-object.md). + Beim Verwenden der Low-Level-API geben Sie verschlüsselungsbezogene Informationen in der `InitiateMultipartUploadRequest` gefolgt von identischen Verschlüsselungsinformationen in jeder `UploadPartRequest` an. In Ihrer `CompleteMultipartUploadRequest` müssen Sie keine verschlüsselungsspezifischen Header angeben. Beispiele finden Sie unter [Verwendung der AWS SDKs (Low-Level-API)](mpu-upload-object.md#mpu-upload-low-level). Das folgende Beispiel dient der Erstellung `TransferManager` von Objekten und zeigt, wie zugehörige Informationen bereitgestellt SSE-C werden. Das Beispiel erledigt Folgendes: + Erstellt ein Objekts mit der Methode `TransferManager.upload()`. In der `PutObjectRequest` Instanz geben Sie in der Anfrage Informationen zum Verschlüsselungsschlüssel 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 verschlüsselt ist SSE-C, stellt das `CopyObjectRequest` auch den Verschlüsselungsschlüssel des Quellobjekts bereit, sodass Amazon S3 das Objekt vor dem Kopieren entschlüsseln kann. **Example** ``` 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 die mehrteilige Upload-API verwenden (siehe[Hochladen und Kopieren von Objekten mit mehrteiligen Uploads in Amazon S3](mpuoverview.md)). AWS SDK for .NET bietet sowohl High-Level- als auch Low-Level-APIs zum Hochladen großer Objekte. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anforderung. + Bei Verwendung der High-Level-`Transfer-Utility `-API stellen Sie wie im Folgenden dargestellt verschlüsselungsspezifische Header in der `TransferUtilityUploadRequest` bereit. Codebeispiele finden Sie unter [Hochladen eines Objekts mit Multipart-Upload](mpu-upload-object.md). ``` TransferUtilityUploadRequest request = new TransferUtilityUploadRequest() { FilePath = filePath, BucketName = existingBucketName, Key = keyName, // Provide encryption information. ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256, ServerSideEncryptionCustomerProvidedKey = {{base64Key}}, }; ``` + Beim Verwenden der Low-Level-API geben Sie verschlüsselungsbezogene Informationen in der Anforderung zum Starten des mehrteiligen Uploads gefolgt von identischen Verschlüsselungs-Informationen in den nachfolgenden Anforderungen zum mehrteiligen Upload an. In der vollständigen Anforderung zum mehrteiligen Upload müssen Sie keine verschlüsselungsspezifischen Header angeben. Beispiele finden Sie unter [Verwendung der AWS SDKs (Low-Level-API)](mpu-upload-object.md#mpu-upload-low-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 in Amazon S3 mit gespeichert SSE-C, und Sie möchten das Zielobjekt auch mit speichern SSE-C. Im Beispiel führen Sie folgende Schritte aus: + 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. **Example** ``` 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 uploadResponses = new List(); // 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 uploadResponses = new List(); // 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(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); } } } } ``` ------