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 von serverseitiger Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C)
Die serverseitige Verschlüsselung dient zum Schutz ruhender Daten. Die serverseitige Verschlüsselung verschlüsselt nur die Objektdaten, nicht die Metadaten des Objekts. Sie können serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) in Ihren Allzweck-Buckets verwenden, um Ihre Daten mit Ihren eigenen Verschlüsselungsschlüsseln zu verschlüsseln. 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.
In den meisten modernen Anwendungsfällen in Amazon S3 wird SSE-C nicht mehr verwendet, da es nicht über die Flexibilität einer serverseitigen Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) oder einer serverseitigen Verschlüsselung mit AWS KMS-Schlüsseln (SSE-KMS) verfügt. Die Anforderung von SSE-C, den Verschlüsselungsschlüssel bei jeder Interaktion mit Ihren SSE-C-verschlüsselten Daten bereitzustellen, macht es unpraktisch, Ihren SSEC-Schlüssel mit anderen Benutzern, Rollen oder AWS Diensten zu teilen, die Daten aus Ihren S3-Buckets lesen, um mit Ihren Daten zu arbeiten. Aufgrund der weit verbreiteten Unterstützung von SSE-KMS verwenden die meisten modernen Workloads keine AWS SSE-C-Verschlüsselung, da ihr die Flexibilität von SSE-KMS fehlt. Weitere Informationen zu SSE-KMS finden Sie unter. [Verwenden der serverseitigen Verschlüsselung mit AWS KMS Schlüsseln (SSE-KMS)](UsingKMSEncryption.md)
Wenn Sie verhindern möchten, dass die SSE-C-Verschlüsselung für Objekte verwendet wird, die in Ihren Bucket geschrieben werden, können Sie die SSEC-Verschlüsselung blockieren, wenn Sie die Standardverschlüsselungskonfiguration Ihres Buckets ändern. Wenn SSE-C für einen Allzweck-Bucket blockiert ist, werden alle`PutObject`,,, Mehrteiligen Upload- oder Replikationsanfragen `CopyObject``PostObject`, die die SSE-C-Verschlüsselung spezifizieren, mit einem Fehler zurückgewiesen. `HTTP 403 AccessDenied` Weitere Informationen zum Blockieren von SSE-C finden Sie unter. [Sperren oder Entsperren von SSE-C für einen Allzweck-Bucket](blocking-unblocking-s3-c-encryption-gpb.md)
Für die Nutzung von SSE-C fallen keine zusätzlichen Gebühren an. Für Anforderungen zum Konfigurieren und Verwenden von SSE-C werden jedoch Standardgebühren für Amazon-S3-Anforderungen berechnet. Informationen zu Preisen finden Sie unter [Amazon S3 – Preise](https://aws.amazon.com/s3/pricing/).
**Wichtig**
Wie [am 19. November 2025 angekündigt, stellt](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service eine neue Standardsicherheitseinstellung für Buckets bereit, die automatisch die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) für alle neuen Allzweck-Buckets deaktiviert. Für bestehende Buckets AWS-Konten ohne SSE-C-verschlüsselte Objekte deaktiviert Amazon S3 auch SSE-C für alle neuen Schreibanforderungen. AWS-Konten Bei Verwendung von SSE-C ändert Amazon S3 die Bucket-Verschlüsselungskonfiguration für keinen der vorhandenen Buckets in diesen Konten. Diese Bereitstellung begann am 6. April 2026 und wird in den nächsten Wochen in 37 AWS Regionen, einschließlich der Regionen AWS China und AWS GovCloud (USA), abgeschlossen sein.
Aufgrund dieser Änderungen müssen Anwendungen, die SSE-C-Verschlüsselung benötigen, SSE-C bewusst aktivieren, indem sie den [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API-Vorgang verwenden, nachdem ein neuer Bucket erstellt wurde. Weitere Informationen zu dieser Änderung finden Sie unter. [Häufig gestellte Fragen zur SSE-C-Standardeinstellung für neue Buckets](default-s3-c-encryption-setting-faq.md)
## Überlegungen vor der Verwendung von SSE-C
+ S3 speichert den Verschlüsselungsschlüssel niemals, wenn Sie SSE-C verwenden. Sie müssen den Verschlüsselungsschlüssel jedes Mal angeben, wenn Sie möchten, dass jemand Ihre mit SSE-C verschlüsselten Daten von S3 herunterlädt.
+ Sie Verwalten ein Mapping, welcher Verschlüsselungsschlüssel für die Verschlüsselung welches Objekts verwendet wurde. Sie sind dafür verantwortlich, zu verwalten, welchen Verschlüsselungsschlüssel Sie für welches Objekt angegeben haben. Das bedeutet auch, dass Sie das Objekt verlieren, wenn Sie den Verschlüsselungsschlüssel verlieren.
+ 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.
+ Dieses Design kann es schwierig machen, Ihren SSE-C-Schlüssel mit anderen Benutzern, Rollen oder AWS Diensten zu teilen, die Sie für die Bearbeitung Ihrer Daten benötigen. Aufgrund der weit verbreiteten Unterstützung von SSE-KMS verwenden die meisten modernen Workloads SSE-C nicht AWS, da es nicht über die Flexibilität von SSE-KMS verfügt. Weitere Informationen zu SSE-KMS finden Sie unter Verwenden der serverseitigen Verschlüsselung mit [KMS-Schlüsseln](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html) (SSE-KMS). AWS
+ Das bedeutet, dass mit SSE-C verschlüsselte Objekte nicht nativ von Managed Services entschlüsselt werden können. AWS
+ Sie müssen HTTPS verwenden, wenn Sie SSEC-Header für Ihre Anfragen angeben.
+ Amazon S3 weist Anfragen über HTTP zurück, wenn SSE-C verwendet wird. Aus Sicherheitsgründen sollten Sie jeden Schlüssel, den Sie versehentlich mittels HTTP senden, als nicht vertrauenswürdig betrachten. Verwerfen Sie den Schlüssel und rotieren Sie ihn wie erforderlich.
+ Wenn Ihr Bucket versionierungsfähig ist, kann jede Objektversion, die Sie hochladen, ihren eigenen Verschlüsselungsschlüssel haben. Sie sind dafür verantwortlich, zu verwalten, welcher Verschlüsselungsschlüssel für welche Objektversion verwendet wurde.
+ SSE-C wird in der Amazon S3 S3-Konsole nicht unterstützt. Sie können die Amazon S3 S3-Konsole nicht verwenden, um ein Objekt hochzuladen und die SSE-C-Verschlüsselung anzugeben. Sie können die Konsole auch nicht verwenden, um ein vorhandenes Objekt zu aktualisieren (beispielsweise durch Ändern der Speicherklasse oder Hinzufügen von Metadaten), das mittels SSE-C gespeichert wurde.
**Topics**
+ [
## Überlegungen vor der Verwendung von SSE-C
](#considerations-before-using-sse-c)
+ [
# Angeben der serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C)
](specifying-s3-c-encryption.md)
+ [
# Sperren oder Entsperren von SSE-C für einen Allzweck-Bucket
](blocking-unblocking-s3-c-encryption-gpb.md)
+ [
# Häufig gestellte Fragen zur SSE-C-Standardeinstellung für neue Buckets
](default-s3-c-encryption-setting-faq.md)
# Angeben der serverseitigen Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C)
Um serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) zu verwenden, stellen Sie zunächst sicher, dass SSE-C in der Standardverschlüsselungskonfiguration Ihres Amazon S3 S3-Allzweck-Buckets kein blockierter Verschlüsselungstyp ist. Falls blockiert, können Sie diesen Verschlüsselungstyp aktivieren, indem Sie Ihre Standardverschlüsselungskonfiguration für den Bucket aktualisieren. Anschließend können Sie SSE-C in Ihren Upload-Anfragen verwenden, indem Sie die erforderlichen Header übergeben. Sehen Sie sich [Amazon S3 S3-Aktionen, die das Schreiben von Daten mit SSE-C unterstützen](#amazon-s3-actions-that-support-writing-data-with-sse-c) das an und stellen Sie sicher, dass Sie das angeben. [S3-API-Header sind für Anfragen zur Verschlüsselung und Entschlüsselung von SSE-C-Objekten erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)
Wenn Sie ein Objekt hochladen, das SSE-C angibt, 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.
Bevor Sie SSE-C verwenden, stellen Sie sicher, dass Sie die überprüft haben. [Überlegungen vor der Verwendung von 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 mit einem Salt versehener Hash-basierter Nachrichtenauthentifizierungscode (HMAC) des Verschlüsselungsschlüssels gespeichert, um zukünftige Anfragen zu überprüfen. 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 eine Bucket-Richtlinie zur Durchsetzung der SSE-C-Verschlüsselung
](#example-bucket-policy-to-enforce-sse-c-encryption)
+ [
## Vorsigniert und SSE-C URLs
](#ssec-and-presignedurl)
+ [
## Anfragen mit SSE-C stellen
](#making-requests-with-sse-c)
+ [
## Verwenden der REST-API
](#using-rest-api-sse-c)
+ [
## Verwenden Sie AWS SDKs zur Angabe von SSE-C für PUT-, GET-, Head- und Copy-Operationen
](#sse-c-using-sdks)
+ [
## Verwenden von AWS SDKs , um SSE-C für mehrteilige Uploads anzugeben
](#sse-c-using-sdks-multipart-uploads)
## SSE-C-Aktionen und erforderliche Header
Die Angabe von SSE-C auf unterstütztem S3 APIs erfordert die Übergabe bestimmter Anforderungsparameter.
**Anmerkung**
Die `PutBucketEncryption` API in Amazon S3 wird verwendet, um die serverseitige Standardverschlüsselung für einen Bucket zu konfigurieren. Unterstützt jedoch `PutBucketEncryption` nicht die Aktivierung von SSE-C als Standardverschlüsselungsmethode für einen Bucket. SSE-C ist eine Verschlüsselungsmethode auf Objektebene, bei der Sie Amazon S3 bei jeder Anfrage zum Hoch- oder Herunterladen von Objekten den Verschlüsselungsschlüssel zur Verfügung stellen. 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. Das bedeutet, dass SSE-C auf Objektbasis aktiviert ist, nicht als Standard-Bucket-Einstellung.
### Amazon S3 S3-Aktionen, die das Schreiben von Daten mit SSE-C unterstützen
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 [Replizieren verschlüsselter Objekte (SSE-S3, SSE-KMS, DSSE-KMS, SSE-C)](replication-config-for-kms-objects.md).
### S3-API-Header sind für Anfragen zur Verschlüsselung und Entschlüsselung von SSE-C-Objekten erforderlich
Sie müssen die folgenden drei API-Header angeben, um Objekte mit SSE-C zu verschlüsseln oder zu entschlüsseln:
+ `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 MD5 128-Bit-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 mit SSE-C verschlüsselten Quellobjekten erforderlich
Sie müssen die folgenden drei API-Header angeben, um mit SSE-C verschlüsselte Quellobjekte zu kopieren:
+ `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 lauten.
+ `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 zur Entschlüsselung 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 MD5 128-Bit-Digest des Verschlüsselungsschlüssels gemäß RFC 1321 bereitzustellen.
## Beispiel für eine Bucket-Richtlinie zur Durchsetzung der SSE-C-Verschlüsselung
Um SSE-C für alle Objekte zu verlangen, die in einen Amazon S3 S3-Bucket geschrieben wurden, können Sie eine Bucket-Richtlinie verwenden. Die folgende Bucket-Richtlinie verweigert beispielsweise die Berechtigung zum Hochladen von Objekten (`s3:PutObject`) für alle Anfragen, die nicht den Header `x-amz-server-side-encryption-customer-algorithm` enthalten, der SSE-C anfordert.
```
{
"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, um SSE-C aktivieren zu lassen`s3:PutObject`, müssen Sie den `x-amz-server-side-encryption-customer-algorithm` Header in alle mehrteiligen Upload-Anfragen (CreateMultipartUpload, und) aufnehmen. UploadPart CompleteMultipartUpload
## Vorsigniert und SSE-C URLs
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. Presigned URLs unterstützt SSE-C wie folgt:
+ 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 non-SSE-C Objekte können Sie eine vorsignierte URL generieren und diese URL direkt in einen Browser einfügen, um auf die Daten zuzugreifen.
Dies ist für SSE-C-Objekte jedoch nicht möglich, da Sie zusätzlich zur vorsignierten URL auch HTTP-Header einfügen müssen, die für SSE-C-Objekte spezifisch sind. Daher können Sie vorsignierte Objekte URLs für SSE-C nur programmgesteuert verwenden.
Weitere Hinweise zu vorsigniert finden Sie unter. URLs [Laden Sie Objekte mit vorsignierten Objekten herunter und laden Sie sie hoch URLs](using-presigned-url.md)
## Anfragen mit SSE-C stellen
Zum Zeitpunkt der Objekterstellung über die REST-API können Sie die 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 von angeben. [S3-API-Header sind für Anfragen zum Kopieren von mit SSE-C verschlüsselten Quellobjekten erforderlich](#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**
Bevor Sie die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) angeben, stellen Sie sicher, dass die SSE-C-Verschlüsselung für Ihren Allzweck-Bucket nicht blockiert ist. Weitere Informationen finden Sie unter [Sperren oder Entsperren von 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 hochzuladen und SSE-C anzufordern. Sie können die Konsole auch nicht verwenden, um ein vorhandenes, mit SSE-C gespeichertes Objekt zu aktualisieren (z. B. die Speicherklasse zu ändern oder Metadaten hinzuzufügen). Weitere Informationen finden Sie unter. [S3-API-Header sind für Anfragen zur Verschlüsselung und Entschlüsselung von SSE-C-Objekten erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)
## Verwenden der REST-API
### Amazon S3 REST APIs , das SSE-C unterstützt
Die folgenden Amazon 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) und jeder nachfolgenden Teil-Upload-Anfrage](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html) (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 SSE-C verschlüsselt wird, müssen Sie Verschlüsselungsinformationen mithilfe der S3-API bereitstellen. [S3-API-Header sind für Anfragen zur Verschlüsselung und Entschlüsselung von SSE-C-Objekten erforderlich](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)
+ Wenn das Quellobjekt mit SSE-C verschlüsselt ist, müssen Sie die Informationen zum Verschlüsselungsschlüssel mithilfe der S3-API-Header angeben. [S3-API-Header sind für Anfragen zum Kopieren von mit SSE-C verschlüsselten Quellobjekten erforderlich](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c)
## Verwenden Sie AWS SDKs zur Angabe von SSE-C für PUT-, GET-, Head- und Copy-Operationen
In den folgenden Beispielen wird gezeigt, wie Sie für Objekte die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) anfordern. 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 wurde, müssen Sie seine Verschlüsselungs-Informationen in Ihrer Kopieranfrage bereitstellen. 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, die den AWS SDK für Java verwenden, 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 [Verwenden 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);
}
}
}
```
------
## Verwenden von AWS SDKs , um SSE-C für mehrteilige Uploads anzugeben
Das Beispiel im obigen Abschnitt zeigt, wie Sie eine serverseitige Verschlüsselung mit einem vom Kunden bereitgestellten Schlüssel (SSE-C) in den PUT-, GET-, Head- und Copy-Vorgänge anfordern. In diesem Abschnitt werden andere Amazon S3 beschrieben APIs , die SSE-C unterstützen.
------
#### [ Java ]
Um große Objekte hochzuladen, können Sie den mehrteiligen Upload verwenden. APIs Weitere Informationen finden Sie unter [Hochladen und Kopieren von Objekten mit mehrteiligen Uploads in Amazon S3](mpuoverview.md). Sie können entweder High-Level oder Low-Level verwenden APIs , um große Objekte hochzuladen. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anfrage.
+ 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 [Verwenden der AWS SDKs (Low-Level-API)](mpu-upload-object.md#mpu-upload-low-level).
Der folgende Beispiel verwendet den `TransferManager`, um Objekte zu erstellen, und zeigt, wie Sie SSE-C-bezogene Informationen bereitstellen. 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 mittels SSE-C verschlüsselt ist, stellt die `CopyObjectRequest` auch den Verschlüsselungsschlüssel des Quellobjekts bereit. Auf diese Weise kann Amazon S3 das Objekt vor dem Kopieren entschlüsseln.
**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 APIs Low-Level-Funktionen zum Hochladen großer Objekte. Diese APIs unterstützen verschlüsselungsbezogene Header in der Anfrage.
+ 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 [Verwenden 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. Im Beispiel wird das zu kopierende Objekt in Amazon S3 mittels SSE-C gespeichert und Sie möchten das Zielobjekt ebenfalls mittels SSE-C speichern. Im Beispiel machen Sie folgendes:
+ 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);
}
}
}
}
```
------
# Sperren oder Entsperren von SSE-C für einen Allzweck-Bucket
Die meisten modernen Anwendungsfälle in Amazon S3 verwenden keine serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) mehr, da ihr die Flexibilität der serverseitigen Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) oder der serverseitigen Verschlüsselung mit KMS-Schlüsseln (SSE-KMS) fehlt. AWS Die Anforderung von SSE-C, den Verschlüsselungsschlüssel bei jeder Interaktion mit Ihren SSE-C-verschlüsselten Daten bereitzustellen, macht es unpraktisch, Ihren SSEC-Schlüssel mit anderen Benutzern, Rollen oder AWS Diensten zu teilen, die Daten aus Ihren S3-Buckets lesen, um mit Ihren Daten zu arbeiten.
Um die serverseitigen Verschlüsselungstypen einzuschränken, die Sie in Ihren Allzweck-Buckets verwenden können, können Sie SSE-C-Schreibanforderungen blockieren, indem Sie Ihre Standardverschlüsselungskonfiguration für Ihre Buckets aktualisieren. Diese Konfiguration auf Bucket-Ebene blockiert Anfragen zum Hochladen von Objekten, die SSE-C spezifizieren. Wenn SSE-C für einen Bucket blockiert ist, werden alle`PutObject`,, oder Multipart Upload- oder Replikationsanfragen `CopyObject``PostObject`, die die SSE-C-Verschlüsselung spezifizieren, mit einem HTTP 403-Fehler zurückgewiesen. `AccessDenied`
Diese Einstellung ist ein Parameter in der `PutBucketEncryption` API und kann auch mit der S3-Konsole, der AWS CLI und AWS SDKs, sofern Sie die `s3:PutEncryptionConfiguration` entsprechende Berechtigung haben, aktualisiert werden.
Gültige Werte sind`SSE-C`, was die SSE-C-Verschlüsselung für den Allzweck-Bucket blockiert, und`NONE`, was die Verwendung von SSE-C für Schreibvorgänge in den Bucket ermöglicht.
**Wichtig**
Wie [am 19. November 2025 angekündigt, stellt](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service eine neue Standardsicherheitseinstellung für Buckets bereit, die automatisch die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) für alle neuen Allzweck-Buckets deaktiviert. Für bestehende Buckets AWS-Konten ohne SSE-C-verschlüsselte Objekte deaktiviert Amazon S3 auch SSE-C für alle neuen Schreibanforderungen. AWS-Konten Bei Verwendung von SSE-C ändert Amazon S3 die Bucket-Verschlüsselungskonfiguration für keinen der vorhandenen Buckets in diesen Konten. Diese Bereitstellung begann am 6. April 2026 und wird in den nächsten Wochen in 37 AWS Regionen, einschließlich der Regionen AWS China und AWS GovCloud (USA), abgeschlossen sein.
Aufgrund dieser Änderungen müssen Anwendungen, die SSE-C-Verschlüsselung benötigen, SSE-C bewusst aktivieren, indem sie den [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API-Vorgang verwenden, nachdem ein neuer Bucket erstellt wurde. Weitere Informationen zu dieser Änderung finden Sie unter. [Häufig gestellte Fragen zur SSE-C-Standardeinstellung für neue Buckets](default-s3-c-encryption-setting-faq.md)
## Berechtigungen
Verwenden Sie die `PutBucketEncryption` API oder die S3-Konsole oder AWS CLI AWS SDKs, um Verschlüsselungstypen für einen Allzweck-Bucket zu blockieren oder zu entsperren. Sie müssen über die folgende Berechtigung verfügen:
+ `s3:PutEncryptionConfiguration`
Verwenden Sie die `GetBucketEncryption` API oder die S3-Konsole oder AWS CLI AWS SDKs, um blockierte Verschlüsselungstypen für einen Allzweck-Bucket anzuzeigen. Sie benötigen die folgende Berechtigung:
+ `s3:GetEncryptionConfiguration`
## Überlegungen vor dem Blockieren der SSE-C-Verschlüsselung
Nachdem Sie SSE-C für einen beliebigen Bucket blockiert haben, gilt das folgende Verschlüsselungsverhalten:
+ Es gibt keine Änderung an der Verschlüsselung der Objekte, die im Bucket vorhanden waren, bevor Sie die SSE-C-Verschlüsselung blockiert haben.
+ Nachdem Sie die SSE-C-Verschlüsselung blockiert haben, können Sie weiterhin HeadObject Anfragen für bereits vorhandene, mit SSE-C verschlüsselte Objekte stellen GetObject , sofern Sie die erforderlichen SSEC-Header für die Anfragen angeben.
+ Wenn SSE-C für einen Bucket blockiert ist, werden alle,, oder Multipart Upload-Anfragen `PutObject``CopyObject`, die die SSE-C-Verschlüsselung spezifizieren`PostObject`, mit einem HTTP 403-Fehler zurückgewiesen. `AccessDenied`
+ Wenn in einem Ziel-Bucket für die Replikation SSE-C blockiert ist und die zu replizierenden Quellobjekte mit SSE-C verschlüsselt sind, schlägt die Replikation mit einem HTTP 403-Fehler fehl. `AccessDenied`
Wenn Sie überprüfen möchten, ob Sie in einem Ihrer Buckets SSE-C-Verschlüsselung verwenden, bevor Sie diesen Verschlüsselungstyp blockieren, können Sie Tools wie die Überwachung des Zugriffs auf Ihre Daten verwenden. [AWS CloudTrail](https://aws.amazon.com/cloudtrail/) In diesem [Blogbeitrag](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/) erfahren Sie, wie Sie Verschlüsselungsmethoden für Objekt-Uploads in Echtzeit überprüfen können. Sie können auch auf diesen [re:POST-Artikel](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets) verweisen, der Sie durch die Abfrage von S3-Inventarberichten führt, um festzustellen, ob Sie über SSE-C-verschlüsselte Objekte verfügen.
### Schritte
Sie können serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) für einen Allzweck-Bucket blockieren oder entsperren, indem Sie die Amazon S3 S3-Konsole, die AWS Command Line Interface (AWS CLI), die Amazon S3 S3-REST-API und verwenden. AWS SDKs
### Verwenden der S3-Konsole
So blockieren oder entsperren Sie die SSE-C-Verschlüsselung für einen Bucket mithilfe der Amazon S3 S3-Konsole:
1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die Amazon S3 S3-Konsole unter https://console.aws.amazon.com/s3/.
1. Wählen Sie im linken Navigationsbereich die Option **Allzweck-Buckets** aus.
1. Wählen Sie den Bucket aus, für den Sie die SSE-C-Verschlüsselung blockieren möchten.
1. Wählen Sie die Registerkarte **Eigenschaften** für den Bucket aus.
1. Navigieren Sie zum Eigenschaftenbereich für die **Standardverschlüsselung** für den Bucket und wählen Sie **Bearbeiten** aus.
1. Aktivieren Sie im Abschnitt **Blockierte Verschlüsselungstypen** das Kontrollkästchen neben **Serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C), um die SSE-C-Verschlüsselung** zu blockieren, oder deaktivieren Sie dieses Kästchen, um SSE-C zuzulassen.
1. Wählen Sie **Änderungen speichern** aus.
### Verwenden des AWS CLI
Informationen zur Installation der AWS CLI finden Sie unter [Installation der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) im *AWS Command Line Interface Benutzerhandbuch*.
Das folgende CLI-Beispiel zeigt Ihnen, wie Sie die SSE-C-Verschlüsselung für einen Allzweck-Bucket mithilfe von blockieren oder entsperren. AWS CLI Um den Befehl zu verwenden, ersetzen Sie den *user input placeholders* durch Ihre eigenen Informationen.
**Anfrage zum Blockieren der SSE-C-Verschlüsselung für einen Allzweck-Bucket:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "SSE-C"
}
}]
}'
```
**Anfrage zur Aktivierung der Verwendung der SSE-C-Verschlüsselung in einem Allzweck-Bucket:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "NONE"
}
}]
}'
```
## Unter Verwendung der AWS SDKs
------
#### [ SDK for Java 2.x ]
Die folgenden Beispiele zeigen Ihnen, wie Sie SSE-C-Verschlüsselungsschreibvorgänge in Ihre Allzweck-Buckets blockieren oder entsperren können, indem Sie AWS SDKs
**Beispiel: PutBucketEncryption Anforderung, die Standardverschlüsselungskonfiguration auf SSE-S3 zu setzen und SSE-C zu blockieren**
```
S3Client s3Client = ...;
ServerSideEncryptionByDefault defaultSse = ServerSideEncryptionByDefault
.builder()
.sseAlgorithm(ServerSideEncryption.AES256)
.build();
BlockedEncryptionTypes blockedEncryptionTypes = BlockedEncryptionTypes
.builder()
.encryptionType(EncryptionType.SSE_C)
.build();
ServerSideEncryptionRule rule = ServerSideEncryptionRule.builder()
.applyServerSideEncryptionByDefault(defaultSse)
.blockedEncryptionTypes(blockedEncryptionTypes)
.build();
s3Client.putBucketEncryption(be -> be
.bucket(bucketName)
.serverSideEncryptionConfiguration(c -> c.rules(rule)));
```
**Beispiel — PutBucketEncryption Anforderung, die Standardverschlüsselungskonfiguration auf SSE-S3 zu setzen und SSE-C zu entsperren**
```
S3Client s3Client = ...;
ServerSideEncryptionByDefault defaultSse = ServerSideEncryptionByDefault
.builder()
.sseAlgorithm(ServerSideEncryption.AES256)
.build();
BlockedEncryptionTypes blockedEncryptionTypes = BlockedEncryptionTypes
.builder()
.encryptionType(EncryptionType.NONE)
.build();
ServerSideEncryptionRule rule = ServerSideEncryptionRule.builder()
.applyServerSideEncryptionByDefault(defaultSse)
.blockedEncryptionTypes(blockedEncryptionTypes)
.build();
s3Client.putBucketEncryption(be -> be
.bucket(bucketName)
.serverSideEncryptionConfiguration(c -> c.rules(rule)));
```
------
#### [ SDK for Python Boto3 ]
**Beispiel — PutBucketEncryption Anforderung, die Standardverschlüsselungskonfiguration auf SSE-S3 zu setzen und SSE-C zu blockieren**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["SSE-C"]
}
}]
}
)
```
**Beispiel — PutBucketEncryption Anforderung, die Standardverschlüsselungskonfiguration auf SSE-S3 zu setzen und SSE-C zu entsperren**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["NONE"]
}
}]
}
)
```
------
## Verwenden der REST-API
Informationen zur Amazon S3 S3-REST-API-Unterstützung für das Blockieren oder Entsperren der SSE-C-Verschlüsselung für einen Allzweck-Bucket finden Sie im folgenden Abschnitt in der *Amazon Simple Storage* Service API-Referenz:
+ [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html)Datentyp, der im [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html)Datentyp der- und API-Operationen verwendet wird [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html). [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)
# Häufig gestellte Fragen zur SSE-C-Standardeinstellung für neue Buckets
**Wichtig**
Wie [am 19. November 2025 angekündigt, stellt](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service eine neue Standardsicherheitseinstellung für Buckets bereit, die automatisch die serverseitige Verschlüsselung mit vom Kunden bereitgestellten Schlüsseln (SSE-C) für alle neuen Allzweck-Buckets deaktiviert. Für bestehende Buckets AWS-Konten ohne SSE-C-verschlüsselte Objekte deaktiviert Amazon S3 auch SSE-C für alle neuen Schreibanforderungen. AWS-Konten Bei Verwendung von SSE-C ändert Amazon S3 die Bucket-Verschlüsselungskonfiguration für keinen der vorhandenen Buckets in diesen Konten. Diese Bereitstellung begann am 6. April 2026 und wird in den nächsten Wochen in 37 AWS Regionen, einschließlich der Regionen AWS China und AWS GovCloud (USA), abgeschlossen sein.
Aufgrund dieser Änderungen müssen Anwendungen, die SSE-C-Verschlüsselung benötigen, SSE-C bewusst aktivieren, indem sie den [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API-Vorgang verwenden, nachdem ein neuer Bucket erstellt wurde.
In den folgenden Abschnitten werden Fragen zu diesem Update beantwortet.
**1. Wird die neue SSE-C-Einstellung im April 2026 für alle neu erstellten Buckets wirksam?**
Ja. Diese Bereitstellung begann am 6. April 2026 und wird in den nächsten Wochen in 37 AWS Regionen, einschließlich der Regionen AWS China und AWS GovCloud (USA), abgeschlossen sein.
**Anmerkung**
Nach Abschluss der Bereitstellung ist für neu erstellte Buckets in allen AWS Regionen außer dem Mittleren Osten (Bahrain) und dem Mittleren Osten (VAE) standardmäßig SSE-C deaktiviert.
**2. Wie lange wird es dauern, bis dieser Rollout alle AWS Regionen abdeckt?**
Die Bereitstellung begann am 6. April 2026 und wird in wenigen Wochen abgeschlossen sein.
**3. Woher weiß ich, dass das Update abgeschlossen ist?**
Sie können ganz einfach feststellen, ob die Änderung in Ihrer AWS Region abgeschlossen wurde, indem Sie einen neuen Bucket erstellen und den [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)API-Vorgang aufrufen, um festzustellen, ob die SSE-C-Verschlüsselung deaktiviert ist. Nach Abschluss des Updates ist die SSE-C-Verschlüsselung für alle neuen Allzweck-Buckets standardmäßig automatisch deaktiviert. Sie können diese Einstellungen anpassen, nachdem Sie Ihren S3-Bucket erstellt haben, indem Sie den [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API-Vorgang aufrufen.
**4. Wird Amazon S3 meine bestehenden Bucket-Konfigurationen aktualisieren?**
Wenn Ihr AWS Konto keine SSE-C-verschlüsselten Objekte enthält, AWS wird die SSEC-Verschlüsselung für all Ihre vorhandenen Buckets deaktiviert. Wenn ein Bucket in Ihrem AWS Konto SSE-C-verschlüsselte Objekte enthält, AWS werden die Bucket-Konfigurationen in keinem Ihrer Buckets in diesem Konto geändert. Sobald die `CreateBucket` Änderung für Ihre AWS Region abgeschlossen ist, gilt die neue Standardeinstellung für alle neuen Allzweck-Buckets.
**5. Kann ich die SSE-C-Verschlüsselung für meine Buckets deaktivieren, bevor das Update abgeschlossen ist?**
Ja. Sie können die SSE-C-Verschlüsselung für jeden Bucket deaktivieren, indem Sie den [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API-Vorgang aufrufen und den neuen Header angeben. `BlockedEncryptionTypes`
**6. Kann ich SSE-C verwenden, um Daten in meinen neuen Buckets zu verschlüsseln?**
Ja. In den meisten modernen Anwendungsfällen in Amazon S3 wird SSE-C nicht mehr verwendet, da es nicht über die Flexibilität verfügt, die serverseitige Verschlüsselung mit verwalteten Amazon S3 S3-Schlüsseln (SSE-S3) oder serverseitiger Verschlüsselung mit AWS KMS-Schlüsseln (SSE-KMS) bietet. Wenn Sie die SSE-C-Verschlüsselung in einem neuen Bucket verwenden müssen, können Sie den neuen Bucket erstellen und dann die Verwendung der SSE-C-Verschlüsselung in einer separaten Anfrage aktivieren. `PutBucketEncryption`
**Beispiel**
```
aws s3api create-bucket \
bucket amzn-s3-demo-bucket \
region us-east-1 \
aws s3api put-bucket-encryption \
-- bucket amzn-s3-demo-bucket \
-- server-side-encryption-configuration \
'{ \Rules\: [{
{
\ApplyServerSideEncryptionByDefault\: {
\SSEAlgorithm\: \AES256\,
},
\BlockedEncryptionTypes\: [
\EncryptionType\:\NONE\]
}
}]
}'
```
**Anmerkung**
Sie müssen die `s3:PutEncryptionConfiguration` Erlaubnis haben, die API aufzurufen. `PutBucketEncryption`
**7. Wie wirkt sich das Blockieren von SSE-C auf Anfragen an meinen Bucket aus?**
Wenn SSE-C für einen Bucket blockiert ist, werden alle`PutObject`,, oder Multipart Upload- oder Replikationsanfragen`PostObject`, die die SSE-C-Verschlüsselung spezifizieren, mit einem HTTP 403-Fehler zurückgewiesen. `CopyObject` `AccessDenied`