Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menggunakan enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C)
Enkripsi sisi-server adalah tentang melindungi data diam. Enkripsi di sisi server hanya mengenkripsi data objek, bukan metadata objek. Anda dapat menggunakan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) di bucket tujuan umum Anda untuk mengenkripsi data Anda dengan kunci enkripsi Anda sendiri. Dengan kunci enkripsi yang Anda sediakan sebagai bagian dari permintaan Anda, Amazon S3 mengelola enkripsi data saat menulis ke disk dan dekripsi data saat Anda mengakses objek Anda. Oleh karena itu, Anda tidak perlu menyimpan kode apa pun untuk melakukan enkripsi dan dekripsi data. Satu-satunya hal yang perlu Anda lakukan adalah mengelola kunci enkripsi yang Anda berikan.
Sebagian besar kasus penggunaan modern di Amazon S3 tidak lagi menggunakan SSE-C karena tidak memiliki fleksibilitas enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3) atau enkripsi sisi server dengan kunci KMS (SSE-KMS). AWS Persyaratan SSE-C untuk menyediakan kunci enkripsi setiap kali Anda berinteraksi dengan data terenkripsi SSE-C Anda membuatnya tidak praktis untuk membagikan kunci SSE-C Anda dengan pengguna, peran, atau AWS layanan lain yang membaca data dari bucket S3 Anda agar dapat beroperasi pada data Anda. Karena dukungan luas untuk SSE-KMS AWS, sebagian besar beban kerja modern tidak menggunakan enkripsi SSE-C karena tidak memiliki fleksibilitas SSE-KMS. Untuk mempelajari lebih lanjut tentang SSE-KMS, lihat. [Menggunakan enkripsi sisi server dengan AWS KMS kunci (SSE-KMS)](UsingKMSEncryption.md)
Jika Anda ingin mencegah enkripsi SSE-C digunakan untuk objek yang ditulis ke bucket, Anda dapat memblokir enkripsi SSE-C saat mengubah konfigurasi enkripsi default bucket Anda. Ketika SSE-C diblokir untuk bucket tujuan umum, setiap,, `PutObject` `CopyObject``PostObject`, Multipart Upload atau permintaan replikasi yang menentukan enkripsi SSE-C akan ditolak dengan kesalahan. `HTTP 403 AccessDenied` Untuk mempelajari lebih lanjut tentang memblokir SSE-C, lihat. [Memblokir atau membuka blokir SSE-C untuk bucket tujuan umum](blocking-unblocking-s3-c-encryption-gpb.md)
Tidak ada biaya tambahan untuk penggunaan SSE-C. Namun, permintaan untuk mengonfigurasi dan menggunakan SSE-C dikenakan biaya permintaan Amazon S3 standar. Untuk informasi tentang harga, lihat [Harga Amazon S3](https://aws.amazon.com/s3/pricing/).
**penting**
Seperti yang [diumumkan pada 19 November 2025,](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 menerapkan pengaturan keamanan bucket default baru yang secara otomatis menonaktifkan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk semua bucket tujuan umum baru. Untuk bucket yang ada tanpa objek terenkripsi SSE-C, Amazon S3 juga akan menonaktifkan SSE-C untuk semua permintaan tulis baru. Akun AWS Untuk Akun AWS penggunaan SSE-C, Amazon S3 tidak akan mengubah konfigurasi enkripsi bucket pada bucket yang ada di akun tersebut. Penyebaran ini dimulai pada 6 April 2026, dan akan selesai selama beberapa minggu ke depan di 37 AWS Wilayah, termasuk Wilayah AWS Tiongkok dan AWS GovCloud (AS).
Dengan perubahan ini, aplikasi yang membutuhkan enkripsi SSE-C harus sengaja mengaktifkan SSE-C dengan menggunakan operasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API setelah membuat bucket baru. Untuk informasi lebih lanjut tentang perubahan ini, lihat[Pengaturan SSE-C standar untuk bucket baru FAQ](default-s3-c-encryption-setting-faq.md).
## Pertimbangan sebelum menggunakan SSE-C
+ S3 tidak pernah menyimpan kunci enkripsi saat Anda menggunakan SSE-C. Anda harus menyediakan kunci enkripsi setiap kali Anda ingin siapa pun mengunduh data terenkripsi SSE-C Anda dari S3.
+ Anda mengelola pemetaan kunci enkripsi mana yang digunakan untuk mengenkripsi objek yang ingin dituju. Anda bertanggung jawab untuk melacak kunci enkripsi yang Anda berikan untuk objek yang ingin dituju. Itu juga berarti jika Anda kehilangan kunci enkripsi, Anda kehilangan objek.
+ Karena Anda mengelola kunci enkripsi di sisi klien, Anda mengelola perlindungan tambahan, seperti rotasi utama, di sisi klien.
+ Desain ini dapat mempersulit berbagi kunci SSE-C Anda dengan pengguna, peran, atau AWS layanan lain yang Anda operasikan pada data Anda. Karena dukungan luas untuk SSE-KMS AWS, sebagian besar beban kerja modern tidak menggunakan SSE-C karena tidak memiliki fleksibilitas SSE-KMS. Untuk mempelajari lebih lanjut tentang SSE-KMS, lihat [Menggunakan enkripsi sisi server dengan kunci KMS (SSE-KMS](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)). AWS
+ Ini berarti bahwa objek yang dienkripsi dengan SSE-C tidak dapat didekripsi secara native oleh layanan terkelola. AWS
+ Anda harus menggunakan HTTPS saat menentukan header SSE-C pada permintaan Anda.
+ Amazon S3 menolak permintaan apa pun yang dibuat melalui HTTP saat menggunakan SSE-C. Untuk pertimbangan keamanan, kami menyarankan Anda mempertimbangkan kunci apa pun yang salah Anda kirimkan melalui HTTP telah disusupi. Buang kuncinya dan putar seperlunya.
+ Jika bucket Anda mengaktifkan versi, setiap versi objek yang Anda unggah dapat memiliki kunci enkripsi sendiri. Anda bertanggung jawab untuk melacak kunci enkripsi yang Anda berikan untuk objek yang ingin dituju.
+ SSE-C tidak didukung di Konsol Amazon S3. Anda tidak dapat menggunakan konsol Amazon S3 untuk mengunggah objek dan menentukan enkripsi SSE-C. Anda juga tidak dapat menggunakan konsol untuk memperbarui (misalnya, mengubah kelas penyimpanan atau menambahkan metadata) objek yang ada yang disimpan menggunakan SSE-C.
**Topics**
+ [Pertimbangan sebelum menggunakan SSE-C](#considerations-before-using-sse-c)
+ [Menentukan enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C)](specifying-s3-c-encryption.md)
+ [Memblokir atau membuka blokir SSE-C untuk bucket tujuan umum](blocking-unblocking-s3-c-encryption-gpb.md)
+ [Pengaturan SSE-C standar untuk bucket baru FAQ](default-s3-c-encryption-setting-faq.md)
# Menentukan enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C)
Untuk menggunakan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) terlebih dahulu pastikan bahwa SSE-C bukan jenis enkripsi yang diblokir dalam konfigurasi enkripsi default bucket tujuan umum Amazon S3 Anda. Jika diblokir, Anda dapat mengaktifkan jenis enkripsi ini dengan memperbarui konfigurasi enkripsi default untuk bucket. Kemudian, Anda dapat menggunakan SSE-C dalam permintaan unggahan Anda dengan meneruskan header yang diperlukan. Lihat[Tindakan Amazon S3 yang mendukung penulisan data dengan SSE-C](#amazon-s3-actions-that-support-writing-data-with-sse-c), dan pastikan untuk menyertakan[Header API S3 diperlukan untuk enkripsi objek SSE-C dan permintaan dekripsi](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests).
Saat Anda mengunggah objek yang menentukan SSE-C, Amazon S3 menggunakan kunci enkripsi yang Anda berikan untuk menerapkan enkripsi AES-256 ke data Anda. Amazon S3 kemudian menghapus kunci enkripsi dari memori. Saat mengambil sebuah objek, Anda harus memberikan kunci enkripsi yang sama sebagai bagian dari permintaan Anda. Amazon S3 pertama-tama memverifikasi bahwa kunci enkripsi yang Anda berikan cocok, lalu mendekripsi objek sebelum mengembalikan data objek kepada Anda.
Sebelum menggunakan SSE-C, pastikan Anda telah meninjau. [Pertimbangan sebelum menggunakan SSE-C](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c)
**catatan**
Amazon S3 tidak menyimpan kunci enkripsi yang Anda sediakan. Sebaliknya, ia menyimpan nilai Kode Autentikasi Pesan Berbasis Hash (HMAC) salted secara acak dari kunci enkripsi untuk memvalidasi permintaan di masa mendatang. Nilai HMAC salted tidak dapat digunakan untuk mendapatkan nilai kunci enkripsi atau untuk mendekripsi konten objek terenkripsi. Artinya, jika Anda kehilangan kunci enkripsi, Anda akan kehilangan objek.
**Topics**
+ [Tindakan SSE-C dan Header yang Diperlukan](#sse-c-actions-and-required-headers)
+ [Contoh kebijakan bucket untuk menegakkan enkripsi SSE-C](#example-bucket-policy-to-enforce-sse-c-encryption)
+ [Presigned URLs dan SSE-C](#ssec-and-presignedurl)
+ [Membuat permintaan dengan SSE-C](#making-requests-with-sse-c)
+ [Penggunaan API REST](#using-rest-api-sse-c)
+ [Menggunakan AWS SDKs untuk menentukan SSE-C untuk operasi PUT, GET, Head, dan Copy](#sse-c-using-sdks)
+ [Menggunakan AWS SDKs untuk menentukan SSE-C untuk unggahan multipart](#sse-c-using-sdks-multipart-uploads)
## Tindakan SSE-C dan Header yang Diperlukan
Menentukan SSE-C pada S3 yang didukung APIs memerlukan melewati parameter permintaan tertentu.
**catatan**
`PutBucketEncryption`API di Amazon S3 digunakan untuk mengonfigurasi enkripsi sisi server default untuk bucket. Namun, `PutBucketEncryption` tidak mendukung pengaktifan SSE-C sebagai metode enkripsi default untuk bucket. SSE-C adalah metode enkripsi tingkat objek tempat Anda memberikan kunci enkripsi ke Amazon S3 dengan setiap permintaan unggahan atau unduhan objek. Amazon S3 menggunakan kunci ini untuk mengenkripsi atau mendekripsi objek selama permintaan dan kemudian membuang kuncinya. Ini berarti SSE-C diaktifkan berdasarkan per-objek, bukan sebagai pengaturan bucket default.
### Tindakan Amazon S3 yang mendukung penulisan data dengan SSE-C
Anda dapat meminta enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) saat menulis objek ke bucket tujuan umum dengan menggunakan operasi atau tindakan API berikut:
+ [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)
**catatan**
S3 Replication mendukung objek yang dienkripsi dengan SSE-C. Untuk informasi selengkapnya tentang mereplikasi objek terenkripsi, lihat [Mereplikasi objek terenkripsi (SSE-S3, SSE-KMS, DSSE-KMS, SSE-C)](replication-config-for-kms-objects.md).
### Header API S3 diperlukan untuk enkripsi objek SSE-C dan permintaan dekripsi
Anda harus menyediakan tiga header API berikut untuk mengenkripsi atau mendekripsi objek dengan SSE-C:
+ `x-amz-server-side-encryption-customer-algorithm`Gunakan header ini untuk menentukan algoritma enkripsi. Nilai header harus berupa AES256.
+ `x-amz-server-side-encryption-customer-key`Gunakan header ini untuk menyediakan kunci enkripsi 256-bit yang disandikan base64 untuk Amazon S3 untuk digunakan untuk mengenkripsi atau mendekripsi data Anda.
+ `x-amz-server-side-encryption-customer-key-MD5`Gunakan header ini untuk memberikan MD5 intisari 128-bit yang dikodekan base64 dari kunci enkripsi menurut RFC 1321. Amazon S3 menggunakan header ini untuk pemeriksaan integritas pesan guna memastikan bahwa kunci enkripsi dikirimkan tanpa kesalahan.
### Header API S3 diperlukan untuk permintaan untuk menyalin objek sumber yang dienkripsi dengan SSE-C
Anda harus menyediakan tiga header API berikut untuk menyalin objek sumber yang dienkripsi dengan SSE-C:
+ `x-amz-copy-source-server-side-encryption-customer-algorithm`Sertakan header ini untuk menentukan algoritme yang harus digunakan Amazon S3 untuk mendekripsi objek sumber. Nilai ini harus berupa AES256.
+ `x-amz-copy-source-server-side-encryption-customer-key`Sertakan header ini untuk menyediakan kunci enkripsi berenkode base64 untuk Amazon S3 untuk digunakan untuk mendekripsi objek sumber. Kunci enkripsi ini harus berupa kunci yang Anda berikan kepada Amazon S3 saat membuat objek sumber. Jika tidak, Amazon S3 tidak dapat mendekripsi objeknya.
+ `x-amz-copy-source-server-side-encryption-customer-key-MD5`Sertakan header ini untuk memberikan MD5 intisari 128-bit yang dikodekan base64 dari kunci enkripsi menurut RFC 1321.
## Contoh kebijakan bucket untuk menegakkan enkripsi SSE-C
Untuk mewajibkan SSE-C untuk semua objek yang ditulis ke bucket Amazon S3, Anda dapat menggunakan kebijakan bucket. Misalnya, kebijakan bucket berikut menolak izin unggah objek (`s3:PutObject`) untuk semua permintaan yang tidak menyertakan header `x-amz-server-side-encryption-customer-algorithm` yang meminta SSE-C.
```
{
"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"
}
}
}
]
}
```
**penting**
Jika Anda menggunakan kebijakan bucket untuk mengharuskan SSE-C aktif`s3:PutObject`, Anda harus menyertakan `x-amz-server-side-encryption-customer-algorithm` header di semua permintaan unggahan multibagian (CreateMultipartUpload, UploadPart, dan). CompleteMultipartUpload
## Presigned URLs dan SSE-C
Anda dapat membuat URL yang telah ditandatangani sebelumnya yang dapat digunakan untuk operasi seperti mengunggah objek baru, mengambil objek yang sudah ada, atau mengambil metadata objek. URLsDukungan presigned SSE-C sebagai berikut:
+ Saat membuat URL yang telah ditandatangani, Anda harus menentukan algoritma dengan menggunakan header `x-amz-server-side-encryption-customer-algorithm` dalam perhitungan tanda tangan.
+ Saat menggunakan URL yang ditandatangani sebelumnya untuk mengunggah objek baru, mengambil objek yang sudah ada, atau mengambil metadata objek saja, Anda harus memberikan semua header enkripsi dalam permintaan aplikasi klien.
**catatan**
Untuk non-SSE-C objek, Anda dapat membuat URL yang telah ditetapkan sebelumnya dan langsung menempelkan URL tersebut ke browser untuk mengakses data.
Namun, Anda tidak dapat melakukan ini untuk objek SSE-C, karena selain URL yang ditandatangani sebelumnya, Anda juga harus menyertakan header HTTP yang kustom untuk objek SSE-C. Oleh karena itu, Anda dapat menggunakan presigned URLs untuk objek SSE-C hanya secara terprogram.
Untuk informasi lebih lanjut tentang presigned URLs, lihat[Unduh dan unggah objek dengan presigned URLs](using-presigned-url.md).
## Membuat permintaan dengan SSE-C
Pada saat pembuatan objek dengan API REST, Anda dapat menentukan enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C). Ketika Anda menggunakan SSE-C, Anda harus memberikan informasi kunci enkripsi menggunakan. [Header API S3 diperlukan untuk permintaan untuk menyalin objek sumber yang dienkripsi dengan SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) Anda dapat menggunakan pustaka pembungkus AWS SDK untuk menambahkan header ini ke permintaan Anda. Jika perlu, Anda dapat melakukan panggilan API REST Amazon S3 secara langsung di aplikasi Anda.
**penting**
Sebelum menentukan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C), pastikan bahwa enkripsi SSE-C tidak diblokir untuk bucket tujuan umum Anda. Untuk informasi selengkapnya, lihat [Memblokir atau membuka blokir SSE-C untuk bucket tujuan umum](blocking-unblocking-s3-c-encryption-gpb.md).
**catatan**
Anda tidak dapat menggunakan konsol Amazon S3 untuk mengunggah objek dan meminta SSE-C. Anda juga tidak dapat menggunakan konsol untuk memperbarui (misalnya, mengubah kelas penyimpanan atau menambahkan metadata) objek yang ada yang disimpan menggunakan SSE-C. Untuk informasi lebih lanjut, lihat[Header API S3 diperlukan untuk enkripsi objek SSE-C dan permintaan dekripsi](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests).
## Penggunaan API REST
### Amazon S3 REST yang mendukung APIs SSE-C
Amazon S3 berikut APIs mendukung enkripsi sisi server dengan kunci enkripsi yang disediakan pelanggan (SSE-C).
+ **GET operation**–Saat mengambil objek menggunakan API GET (lihat [GET Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)), Anda dapat menentukan header permintaan.
+ **HEAD operation**–Untuk mengambil metadata objek menggunakan API HEAD (lihat [HEAD Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)), Anda dapat menentukan header permintaan ini.
+ **PUT operation**–Saat Anda mengunggah data dengan menggunakan API PUT Objek (lihat [PUT Objek](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)), Anda dapat menentukan header permintaan ini.
+ **Unggahan Multibagian**–Saat mengunggah objek yang berukuran besar menggunakan API unggahan multibagian, Anda dapat menentukan header ini. [Anda menentukan header ini dalam permintaan inisiat (lihat Memulai [Unggahan Multibagian) dan setiap permintaan unggahan](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html) bagian berikutnya (lihat Bagian Unggah atau). [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html) Untuk setiap permintaan unggahan bagian, informasi enkripsi harus sama dengan yang Anda berikan dalam permintaan unggahan multibagian.
+ **POST operation**–Saat menggunakan POST operation untuk mengunggah objek (lihat [Objek POST](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)), alih-alih dengan header permintaan, Anda memberikan informasi yang sama di dalam bidang formulir.
+ **Salin operasi** — Saat Anda menyalin objek (lihat [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)), Anda memiliki objek sumber dan objek target:
+ Jika Anda ingin menentukan jenis enkripsi objek target, Anda harus memberikan header `x-amz-server-side-encryption ` permintaan.
+ Jika Anda ingin objek target dienkripsi menggunakan SSE-C, Anda harus memberikan informasi enkripsi menggunakan S3 API. [Header API S3 diperlukan untuk enkripsi objek SSE-C dan permintaan dekripsi](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)
+ Jika objek sumber dienkripsi menggunakan SSE-C, Anda harus memberikan informasi kunci enkripsi menggunakan header S3 API. [Header API S3 diperlukan untuk permintaan untuk menyalin objek sumber yang dienkripsi dengan SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c)
## Menggunakan AWS SDKs untuk menentukan SSE-C untuk operasi PUT, GET, Head, dan Copy
Contoh berikut ini menunjukkan cara untuk meminta enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk objek. Contoh melakukan operasi berikut. Setiap operasi menunjukkan cara menentukan SSE-C-related header dalam permintaan:
+ **Put objek**–Mengunggah objek dan meminta enkripsi di sisi server menggunakan kunci enkripsi yang disediakan pelanggan.
+ **Get object**–Mengunduh objek yang diunggah dalam langkah sebelumnya. Dalam permintaan tersebut, Anda memberikan informasi enkripsi yang sama dengan yang Anda berikan saat unggah objek tersebut. Amazon S3 memerlukan informasi ini untuk mendekripsi objek sehingga dapat mengembalikannya kepada Anda.
+ **Get object metadata**–Mengambil metadata objek. Anda memberikan informasi enkripsi yang sama, yang digunakan saat objek tersebut dibuat.
+ **Copy object**–Membuat salinan dari objek yang diunggah sebelumnya. Karena objek sumber disimpan menggunakan SSE-C, Anda harus memberikan informasi enkripsinya dalam permintaan salinan Anda. Secara default, Amazon S3 mengenkripsi salinan objek hanya jika Anda secara eksplisit memintanya. Contoh ini mengarahkan Amazon S3 untuk menyimpan salinan objek yang dienkripsi.
------
#### [ Java ]
**catatan**
Contoh ini menunjukkan cara untuk mengunggah objek dalam satu operasi. Saat menggunakan API Unggahan Multibagian untuk mengunggah objek besar, Anda memberikan informasi enkripsi dengan cara yang sama seperti yang ditunjukkan dalam contoh ini. Untuk contoh unggahan multipart yang menggunakan file AWS SDK untuk Java, lihat. [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md)
Untuk menambahkan informasi enkripsi yang diperlukan, Anda menyertakan `SSECustomerKey` dalam permintaan Anda. Untuk informasi selengkapnya tentang kelas `SSECustomerKey`, lihat bagian API REST.
Untuk petunjuk cara membuat dan menguji sampel yang berfungsi, lihat [Memulai](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) di Panduan AWS SDK untuk Java Pengembang.
**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 ]
**catatan**
Untuk contoh pengunggahan objek besar menggunakan API unggahan multibagian, lihat [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md) dan [Menggunakan AWS SDKs (API tingkat rendah)](mpu-upload-object.md#mpu-upload-low-level).
Untuk informasi tentang menyiapkan dan menjalankan contoh kode, lihat [Memulai SDK for .NET di AWSAWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .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);
}
}
}
```
------
## Menggunakan AWS SDKs untuk menentukan SSE-C untuk unggahan multipart
Contoh di bagian sebelumnya menunjukkan cara meminta enkripsi di sisi server dengan kunci yang disediakan pelanggan (SSE-C) dalam operasi PUT, GET, Head, dan Copy. Bagian ini menjelaskan Amazon S3 lain APIs yang mendukung SSE-C.
------
#### [ Java ]
Untuk mengunggah objek besar, Anda dapat menggunakan unggahan APIs multipart. Untuk informasi selengkapnya, lihat [Mengunggah dan menyalin objek menggunakan unggahan multipart di Amazon S3](mpuoverview.md). Anda dapat menggunakan level tinggi atau level rendah APIs untuk mengunggah objek besar. Ini APIs mendukung header terkait enkripsi dalam permintaan.
+ Saat menggunakan `TransferManager` API tingkat tinggi, Anda menyediakan header khusus enkripsi di. `PutObjectRequest` Untuk informasi selengkapnya, lihat [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md).
+ Saat menggunakan API tingkat rendah, Anda memberikan informasi terkait enkripsi pada `InitiateMultipartUploadRequest`, diikuti dengan informasi enkripsi identik pada setiap `UploadPartRequest`. Anda tidak perlu memberikan header kustom enkripsi apa pun dalam `CompleteMultipartUploadRequest` Anda. Sebagai contoh, lihat [Menggunakan AWS SDKs (API tingkat rendah)](mpu-upload-object.md#mpu-upload-low-level).
Contoh berikut menggunakan `TransferManager` untuk membuat objek dan menunjukkan cara memberikan informasi terkait SSE-C. Contoh ini melakukan hal berikut:
+ Membuat objek menggunakan metode `TransferManager.upload()`. Dalam `PutObjectRequest` contoh, Anda memberikan informasi kunci enkripsi dalam permintaan. Amazon S3 mengenkripsi objek menggunakan kunci yang disediakan pelanggan.
+ Membuat salinan objek dengan memanggil metode `TransferManager.copy()`. Contoh tersebut mengarahkan Amazon S3 untuk mengenkripsi salinan objek menggunakan `SSECustomerKey` yang baru. Karena objek sumber dienkripsi menggunakan SSE-C, `CopyObjectRequest` juga menyediakan kunci enkripsi objek sumber sehingga Amazon S3 dapat mendekripsi objek tersebut sebelum menyalinnya.
**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 ]
Untuk mengunggah objek besar, Anda dapat menggunakan API unggahan multibagian (lihat[Mengunggah dan menyalin objek menggunakan unggahan multipart di Amazon S3](mpuoverview.md)). AWS SDK for .NET menyediakan level tinggi atau APIs level rendah untuk mengunggah objek besar. Ini APIs mendukung header terkait enkripsi dalam permintaan.
+ Saat menggunakan API `Transfer-Utility ` tingkat tinggi, Anda menyediakan header kustom enkripsi di `TransferUtilityUploadRequest` seperti yang ditunjukkan. Untuk contoh kode, lihat [Pengunggahan objek menggunakan unggahan multibagian](mpu-upload-object.md).
```
TransferUtilityUploadRequest request = new TransferUtilityUploadRequest()
{
FilePath = filePath,
BucketName = existingBucketName,
Key = keyName,
// Provide encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
```
+ Saat menggunakan API tingkat rendah, Anda memberikan informasi terkait enkripsi dalam memulai permintaan unggahan multibagian, diikuti dengan informasi enkripsi yang sama dalam permintaan bagian unggahan berikutnya. Anda tidak perlu memberikan header kustom enkripsi apa pun dalam permintaan pengunggahan multibagian lengkap Anda. Sebagai contoh, lihat [Menggunakan AWS SDKs (API tingkat rendah)](mpu-upload-object.md#mpu-upload-low-level).
Berikut ini adalah contoh pengunggahan multibagian tingkat rendah yang membuat salinan objek besar yang sudah ada. Pada contoh, objek yang akan disalin disimpan di Amazon S3 menggunakan SSE-C, dan Anda ingin menyimpan objek target juga menggunakan SSE-C. Dalam contoh ini, Anda melakukan hal berikut:
+ Mulai permintaan pengunggahan multibagian dengan memberikan kunci enkripsi dan informasi terkait.
+ Menyediakan kunci enkripsi objek sumber dan sasaran serta informasi terkait dalam `CopyPartRequest`.
+ Dapatkan ukuran objek sumber yang akan disalin dengan mengambil metadata objek.
+ Unggah objek ke dalam bagian 5 MB.
**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);
}
}
}
}
```
------
# Memblokir atau membuka blokir SSE-C untuk bucket tujuan umum
Sebagian besar kasus penggunaan modern di Amazon S3 tidak lagi menggunakan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) karena tidak memiliki fleksibilitas enkripsi sisi server dengan kunci terkelola Amazon S3 (SSE-S3) atau enkripsi sisi server dengan kunci KMS (SSE-KMS). AWS Persyaratan SSE-C untuk menyediakan kunci enkripsi setiap kali Anda berinteraksi dengan data terenkripsi SSE-C Anda membuatnya tidak praktis untuk membagikan kunci SSE-C Anda dengan pengguna, peran, atau AWS layanan lain yang membaca data dari bucket S3 Anda agar dapat beroperasi pada data Anda.
Untuk membatasi jenis enkripsi sisi server yang dapat Anda gunakan di bucket tujuan umum, Anda dapat memilih untuk memblokir permintaan penulisan SSE-C dengan memperbarui konfigurasi enkripsi default untuk bucket Anda. Konfigurasi tingkat ember ini memblokir permintaan untuk mengunggah objek yang menentukan SSE-C. Ketika SSE-C diblokir untuk bucket, setiap,, `PutObject` `CopyObject``PostObject`, atau Multipart Upload atau permintaan replikasi yang menentukan enkripsi SSE-C akan ditolak dengan kesalahan HTTP 403. `AccessDenied`
Pengaturan ini adalah parameter pada `PutBucketEncryption` API dan juga dapat diperbarui menggunakan Konsol S3, AWS CLI, AWS SDKs dan, jika Anda memiliki `s3:PutEncryptionConfiguration` izin.
Nilai yang valid adalah`SSE-C`, yang memblokir enkripsi SSE-C untuk bucket tujuan umum, dan`NONE`, yang memungkinkan penggunaan SSE-C untuk menulis ke bucket.
**penting**
Seperti yang [diumumkan pada 19 November 2025,](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 menerapkan pengaturan keamanan bucket default baru yang secara otomatis menonaktifkan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk semua bucket tujuan umum baru. Untuk bucket yang ada tanpa objek terenkripsi SSE-C, Amazon S3 juga akan menonaktifkan SSE-C untuk semua permintaan tulis baru. Akun AWS Untuk Akun AWS penggunaan SSE-C, Amazon S3 tidak akan mengubah konfigurasi enkripsi bucket pada bucket yang ada di akun tersebut. Penyebaran ini dimulai pada 6 April 2026, dan akan selesai selama beberapa minggu ke depan di 37 AWS Wilayah, termasuk Wilayah AWS Tiongkok dan AWS GovCloud (AS).
Dengan perubahan ini, aplikasi yang membutuhkan enkripsi SSE-C harus sengaja mengaktifkan SSE-C dengan menggunakan operasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API setelah membuat bucket baru. Untuk informasi lebih lanjut tentang perubahan ini, lihat[Pengaturan SSE-C standar untuk bucket baru FAQ](default-s3-c-encryption-setting-faq.md).
## Izin
Gunakan `PutBucketEncryption` API atau Konsol S3 AWS SDKs, atau AWS CLI untuk memblokir atau membuka blokir jenis enkripsi untuk bucket tujuan umum. Anda harus memiliki izin berikut:
+ `s3:PutEncryptionConfiguration`
Gunakan `GetBucketEncryption` API atau Konsol S3 AWS SDKs, atau AWS CLI untuk melihat jenis enkripsi yang diblokir untuk bucket tujuan umum. Anda harus memiliki izin berikut:
+ `s3:GetEncryptionConfiguration`
## Pertimbangan sebelum memblokir enkripsi SSE-C
Setelah Anda memblokir SSE-C untuk bucket apa pun, perilaku enkripsi berikut akan berlaku:
+ Tidak ada perubahan pada enkripsi objek yang ada di bucket sebelum Anda memblokir enkripsi SSE-C.
+ Setelah Anda memblokir enkripsi SSE-C, Anda dapat terus membuat GetObject dan HeadObject meminta objek yang sudah ada sebelumnya yang dienkripsi dengan SSE-C selama Anda memberikan header SSE-C yang diperlukan pada permintaan.
+ Ketika SSE-C diblokir untuk bucket, permintaan Unggahan`PutObject`,, `CopyObject``PostObject`, atau Multipart apa pun yang menentukan enkripsi SSE-C akan ditolak dengan kesalahan HTTP 403. `AccessDenied`
+ Jika bucket tujuan untuk replikasi telah diblokir SSE-C dan objek sumber yang direplikasi dienkripsi dengan SSE-C, replikasi akan gagal dengan kesalahan HTTP 403. `AccessDenied`
Jika Anda ingin meninjau apakah Anda menggunakan enkripsi SSE-C di salah satu bucket Anda sebelum memblokir jenis enkripsi ini, Anda dapat menggunakan alat seperti [AWS CloudTrail](https://aws.amazon.com/cloudtrail/)untuk memantau akses ke data Anda. [Posting blog](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/) ini menunjukkan kepada Anda cara mengaudit metode enkripsi untuk unggahan objek secara real time. Anda juga dapat mereferensikan [artikel re:Post](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets) ini untuk memandu Anda melalui laporan Inventaris S3 kueri untuk melihat apakah Anda memiliki objek terenkripsi SSE-C.
### Langkah-langkah
Anda dapat memblokir atau membuka blokir enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk bucket tujuan umum dengan menggunakan konsol Amazon S3, (), Amazon S3 REST API AWS Command Line Interface ,AWS CLI dan. AWS SDKs
### Menggunakan konsol S3
Untuk memblokir atau membuka blokir enkripsi SSE-C untuk bucket menggunakan konsol Amazon S3:
1. Masuk ke Konsol AWS Manajemen dan buka konsol Amazon S3 di. https://console.aws.amazon.com/s3/
1. Di panel navigasi kiri, pilih **ember tujuan umum**.
1. Pilih bucket yang ingin Anda blokir enkripsi SSE-C.
1. Pilih tab **Properties** untuk bucket.
1. Arahkan ke panel properti **Enkripsi Default** untuk bucket dan pilih **Edit**.
1. Di bagian **Jenis enkripsi yang diblokir**, centang kotak di sebelah Enkripsi **sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk memblokir enkripsi SSE-C** atau hapus centang pada kotak ini untuk mengizinkan SSE-C.
1. Pilih **Simpan Perubahan**.
### Menggunakan AWS CLI
*Untuk menginstal AWS CLI, lihat [Menginstal AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) di Panduan Pengguna.AWS Command Line Interface *
Contoh CLI berikut menunjukkan cara memblokir atau membuka blokir enkripsi SSE-C untuk bucket tujuan umum dengan menggunakan file. AWS CLI Untuk menggunakan perintah ganti *user input placeholders* dengan informasi Anda sendiri.
**Permintaan untuk memblokir enkripsi SSE-C untuk bucket tujuan umum:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "SSE-C"
}
}]
}'
```
**Permintaan untuk mengaktifkan penggunaan enkripsi SSE-C pada bucket tujuan umum:**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "NONE"
}
}]
}'
```
## Menggunakan AWS SDKs
------
#### [ SDK for Java 2.x ]
Contoh berikut menunjukkan kepada Anda cara memblokir atau membuka blokir enkripsi SSE-C menulis ke bucket tujuan umum Anda dengan menggunakan AWS SDKs
**Contoh - PutBucketEncryption permintaan pengaturan konfigurasi enkripsi default ke SSE-S3 dan memblokir SSE-C**
```
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)));
```
**Contoh - PutBucketEncryption permintaan pengaturan konfigurasi enkripsi default ke SSE-S3 dan membuka blokir SSE-C**
```
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 ]
**Contoh - PutBucketEncryption permintaan pengaturan konfigurasi enkripsi default ke SSE-S3 dan memblokir SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["SSE-C"]
}
}]
}
)
```
**Contoh - PutBucketEncryption permintaan pengaturan konfigurasi enkripsi default ke SSE-S3 dan membuka blokir SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["NONE"]
}
}]
}
)
```
------
## Penggunaan API REST
Untuk informasi tentang dukungan Amazon S3 REST API untuk memblokir atau membuka blokir enkripsi SSE-C untuk bucket tujuan umum, lihat bagian berikut di Referensi API Layanan Penyimpanan Sederhana *Amazon*:
+ [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html)tipe data yang digunakan dalam tipe [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html)data operasi [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)dan [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)API.
# Pengaturan SSE-C standar untuk bucket baru FAQ
**penting**
Seperti yang [diumumkan pada 19 November 2025,](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 menerapkan pengaturan keamanan bucket default baru yang secara otomatis menonaktifkan enkripsi sisi server dengan kunci yang disediakan pelanggan (SSE-C) untuk semua bucket tujuan umum baru. Untuk bucket yang ada tanpa objek terenkripsi SSE-C, Amazon S3 juga akan menonaktifkan SSE-C untuk semua permintaan tulis baru. Akun AWS Untuk Akun AWS penggunaan SSE-C, Amazon S3 tidak akan mengubah konfigurasi enkripsi bucket pada bucket yang ada di akun tersebut. Penyebaran ini dimulai pada 6 April 2026, dan akan selesai selama beberapa minggu ke depan di 37 AWS Wilayah, termasuk Wilayah AWS Tiongkok dan AWS GovCloud (AS).
Dengan perubahan ini, aplikasi yang membutuhkan enkripsi SSE-C harus sengaja mengaktifkan SSE-C dengan menggunakan operasi [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API setelah membuat bucket baru.
Bagian berikut menjawab pertanyaan tentang pembaruan ini.
**1. Pada April 2026, akankah pengaturan SSE-C baru berlaku untuk semua bucket yang baru dibuat?**
Ya. Penyebaran ini dimulai pada 6 April 2026, dan akan selesai selama beberapa minggu ke depan di 37 AWS Wilayah, termasuk Wilayah AWS Tiongkok dan AWS GovCloud (AS).
**catatan**
Setelah penyebaran selesai, bucket yang baru dibuat di semua AWS Wilayah kecuali Timur Tengah (Bahrain) dan Timur Tengah (UEA) akan menonaktifkan SSE-C secara default.
**2. Berapa lama waktu yang dibutuhkan sebelum peluncuran ini mencakup semua Wilayah? AWS **
Penyebaran dimulai pada 6 April 2026, dan akan selesai dalam beberapa minggu.
**3. Bagaimana saya tahu bahwa pembaruan sudah selesai?**
Anda dapat dengan mudah menentukan apakah perubahan telah selesai di AWS Wilayah Anda dengan membuat bucket baru dan memanggil operasi [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)API untuk menentukan apakah enkripsi SSE-C dinonaktifkan. Setelah pembaruan selesai, semua bucket tujuan umum baru akan secara otomatis menonaktifkan enkripsi SSE-C secara default. Anda dapat menyesuaikan pengaturan ini setelah membuat bucket S3 dengan memanggil operasi [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API.
**4. Akankah Amazon S3 memperbarui konfigurasi bucket saya yang ada?**
Jika AWS akun Anda tidak memiliki objek terenkripsi SSE-C, AWS akan menonaktifkan enkripsi SSE-C pada semua bucket yang ada. Jika ada bucket di AWS akun Anda yang memiliki objek terenkripsi SSE-C, tidak AWS akan mengubah konfigurasi bucket pada bucket mana pun di akun tersebut. Setelah `CreateBucket` perubahan selesai untuk AWS Wilayah Anda, pengaturan default baru akan berlaku untuk semua bucket tujuan umum yang baru.
**5. Dapatkah saya menonaktifkan enkripsi SSE-C untuk bucket saya sebelum pembaruan selesai?**
Ya. Anda dapat menonaktifkan enkripsi SSE-C untuk bucket apa pun dengan memanggil operasi [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API dan menentukan header baru. `BlockedEncryptionTypes`
**6. Dapatkah saya menggunakan SSE-C untuk mengenkripsi data di bucket baru saya?**
Ya. Sebagian besar kasus penggunaan modern di Amazon S3 tidak lagi menggunakan SSE-C karena tidak memiliki fleksibilitas enkripsi sisi server adalah dengan kunci terkelola Amazon S3 (SSE-S3) atau enkripsi sisi server dengan kunci KMS (SSE-KMS). AWS Jika Anda perlu menggunakan enkripsi SSE-C di bucket baru, Anda dapat membuat bucket baru dan kemudian mengaktifkan penggunaan enkripsi SSE-C dalam permintaan terpisah. `PutBucketEncryption`
**Contoh**
```
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\]
}
}]
}'
```
**catatan**
Anda harus memiliki `s3:PutEncryptionConfiguration` izin untuk memanggil `PutBucketEncryption` API.
**7. Bagaimana cara memblokir SSE-C memengaruhi permintaan ke bucket saya?**
Ketika SSE-C diblokir untuk bucket, setiap,, `PutObject` `CopyObject``PostObject`, atau Multipart Upload atau permintaan replikasi yang menentukan enkripsi SSE-C akan ditolak dengan kesalahan HTTP 403. `AccessDenied`