本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 使用加密來保護資料
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
資料保護是指保護往返 Amazon S3 的傳輸中資料，以及存放在 Amazon S3 資料中心內磁碟的靜態資料。您可以使用 Secure Socket Layer/Transport Layer Security (SSL/TLS) 保護傳輸中的資料，包括混合式後量子金鑰交換或用戶端加密。下列選項皆可讓您保護 Amazon S3 中的靜態資料：
+ **伺服器端加密** – Amazon S3 會在將物件儲存在 AWS 資料中心的磁碟上之前加密物件，然後在下載物件時解密物件。
根據預設，所有 Amazon S3 儲存貯體都設定了加密，所有上傳到 S3 儲存貯體的新物件都會在靜態時自動加密。伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 是 Amazon S3 中每個儲存貯體的預設加密組態。若要使用不同類型的加密，您可以指定 S3 `PUT` 請求中要使用的伺服器端加密類型，也可以在目的地儲存貯體中更新預設加密組態。
如果您想要在`PUT`請求中指定不同的加密類型，您可以使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)、雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)，或使用客戶提供的金鑰 (SSE-C) 進行伺服器端加密。若您想在目的地儲存貯體中設定不同的預設加密組態，您可以使用 SSE-KMS 或 DSSE-KMS。
如需變更一般用途儲存貯體之預設加密組態的詳細資訊，請參閱 [設定預設加密](default-bucket-encryption.md)。
當您將儲存貯體的預設加密組態變更為 SSE-KMS 時，並不會變更儲存貯體中現有 Amazon S3 物件的加密類型。若要在將預設加密組態更新為 SSE-KMS 之後變更既有物件的加密類型，您可以使用 Amazon S3 Batch Operations。您為 S3 Batch Operations 提供物件清單，而批次操作會呼叫個別 API 操作。您可以使用 [複製物件](batch-ops-copy-object.md) 動作來複製現有物件，該動作會將它們寫回與 SSE-KMS 加密物件相同的儲存貯體。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章[如何使用 S3 庫存清單、Amazon Athena 和 S3 Batch Operations 來追溯加密 Amazon S3 中的現有物件](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)。
如需伺服器端加密的每個選項的詳細資訊，請參閱 [使用伺服器端加密保護資料](serv-side-encryption.md)。
若要設定伺服器端加密，請參閱：
+ [使用 Amazon S3 受管金鑰 (SSE-S3) 指定伺服器端加密](specifying-s3-encryption.md)
+ [使用 AWS KMS (SSE-KMS) 指定伺服器端加密](specifying-kms-encryption.md)
+ [使用 AWS KMS 金鑰指定雙層伺服器端加密 (DSSE-KMS)](specifying-dsse-encryption.md)
+ [使用客戶提供金鑰 (SSC-C) 指定伺服器端加密](specifying-s3-c-encryption.md)
+ **用戶端加密** - 在用戶端加密資料，並將加密的資料上傳至 Amazon S3。在這種情況下，您可以管理加密程序、加密金鑰和相關工具。
若要設定用戶端加密，請參閱 [使用用戶端加密保護資料](UsingClientSideEncryption.md)。
若要查看多少百分比的儲存體位元組已加密，您可以使用 Amazon S3 Storage Lens 指標。S3 Storage Lens 是一種雲端儲存體分析功能，您可以用來了解整個組織使用物件儲存體的情況及其活動情形。如需詳細資訊，請參閱[使用 S3 Storage Lens 評估儲存活動和用量](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens?icmpid=docs_s3_user_guide_UsingEncryption.html)。如需完整的指標清單，請參閱 [S3 Storage Lens 指標詞彙表](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens_metrics_glossary.html?icmpid=docs_s3_user_guide_UsingEncryption)。
如需伺服器端加密、用戶端加密和傳輸中加密的詳細資訊，請參閱下列主題。
**Topics**
+ [
# 使用伺服器端加密保護資料
](serv-side-encryption.md)
+ [
# 使用用戶端加密保護資料
](UsingClientSideEncryption.md)
+ [
# 使用加密保護傳輸中的資料
](UsingEncryptionInTransit.md)
# 使用伺服器端加密保護資料
**重要**
如 [2025 年 11 月 19 日所宣布](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 正在部署新的預設儲存貯體安全設定，以針對所有新的一般用途儲存貯體自動停用使用客戶提供金鑰 (SSE-C) 的伺服器端加密。對於 中沒有 SSE-C 加密物件 AWS 帳戶 的現有儲存貯體，Amazon S3 也會為所有新的寫入請求停用 SSE-C。對於 AWS 帳戶 使用 SSE-C 的 ，Amazon S3 不會變更這些帳戶中任何現有儲存貯體的儲存貯體加密組態。此部署從 2026 年 4 月 6 日開始，並將在接下來的幾週內在 37 AWS 個區域完成，包括 AWS 中國和 AWS GovCloud (US) 區域。
透過這些變更，需要 SSE-C 加密的應用程式必須在建立新儲存貯體後，使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作刻意啟用 SSE-C。如需此變更的詳細資訊，請參閱 [新儲存貯體的預設 SSE-C 設定常見問答集](default-s3-c-encryption-setting-faq.md)。
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
伺服器端加密是指接收資料的應用程式或服務在目的地將資料加密。Amazon S3 會在將資料寫入 AWS 資料中心的磁碟時，在物件層級加密資料，並在您存取資料時將其解密。只要您驗證要求並具備存取許可，存取加密物件或未加密物件的方式並無不同。例如，如果您使用預先簽章的 URL 來分享物件，加密物件與未加密物件的 URL 運作方式會相同。此外，當您列出儲存貯體中的物件時，清單 API 操作會傳回所有物件清單，無論其是否經過加密。
根據預設，所有 Amazon S3 儲存貯體都設定了加密，所有上傳到 S3 儲存貯體的新物件都會在靜態時自動加密。伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 是 Amazon S3 中每個儲存貯體的預設加密組態。若要使用不同類型的加密，您可以指定 S3 `PUT` 請求中要使用的伺服器端加密類型，也可以在目的地儲存貯體中更新預設加密組態。
如果您想要在`PUT`請求中指定不同的加密類型，您可以使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)、雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)，或使用客戶提供的金鑰 (SSE-C) 進行伺服器端加密。若您想在目的地儲存貯體中設定不同的預設加密組態，您可以使用 SSE-KMS 或 DSSE-KMS。
如需變更一般用途儲存貯體之預設加密組態的詳細資訊，請參閱 [設定預設加密](default-bucket-encryption.md)。
當您將儲存貯體的預設加密組態變更為 SSE-KMS 時，並不會變更儲存貯體中現有 Amazon S3 物件的加密類型。若要在將預設加密組態更新為 SSE-KMS 之後變更既有物件的加密類型，您可以使用 Amazon S3 Batch Operations。您為 S3 Batch Operations 提供物件清單，而批次操作會呼叫個別 API 操作。您可以使用 [複製物件](batch-ops-copy-object.md) 動作來複製現有物件，該動作會將它們寫回與 SSE-KMS 加密物件相同的儲存貯體。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章[如何使用 S3 庫存清單、Amazon Athena 和 S3 Batch Operations 來追溯加密 Amazon S3 中的現有物件](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)。
**注意**
您不可以同時對同一個物件套用不同類型的伺服器端加密。
若您需要加密現有物件，請使用 S3 批次操作和 S3 清查。如需詳細資訊，請參閱[使用 Amazon S3 批次操作來加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)和 [使用 Batch Operations 大量執行物件操作](batch-ops.md)。
將資料儲存在 Amazon S3 中時，您有四種互斥的伺服器端加密選項，視您選擇管理加密金鑰的方式，以及您想套用的加密層級數量，針對伺服器端加密而定。
**使用 Amazon S3 受管金鑰 (SSE-S3) 的伺服器端加密**
根據預設，所有 Amazon S3 儲存貯體都設定了加密。伺服器端加密的預設為使用 Amazon S3 受管金鑰 (SSE-S3)。每個物件都使用不重複的金鑰加密。SSE-S3 使用定期輪換的根金鑰自行加密金鑰，提供額外的防護。SSE-S3 使用目前最強大的其中一種區塊加密法 (256 位元進階加密標準 (AES-256))，加密您的資料。如需詳細資訊，請參閱[使用 Amazon S3 受管金鑰 (SSE-S3) 進行伺服器端加密](UsingServerSideEncryption.md)。
**使用 AWS Key Management Service (AWS KMS) 金鑰的伺服器端加密 (SSE-KMS)**
使用 AWS KMS keys (SSE-KMS) 的伺服器端加密是透過整合 AWS KMS 服務與 Amazon S3 來提供。使用 AWS KMS，您可以更好地控制您的金鑰。例如，您可以檢視個別金鑰、編輯控制政策，並遵循 AWS CloudTrail中的金鑰。此外，您可以建立和管理客戶受管金鑰，或是使用您、您服務和您區域唯一的 AWS 受管金鑰 。如需詳細資訊，請參閱[搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。
**使用 AWS Key Management Service (AWS KMS) 金鑰的雙層伺服器端加密 (DSSE-KMS)**
使用 AWS KMS keys (DSSE-KMS) 的雙層伺服器端加密類似於 SSE-KMS，但 DSSE-KMS 套用兩個獨立的 AES-256 加密層，而不是一層：首先使用 AWS KMS 資料加密金鑰，然後使用單獨的 Amazon S3-managed加密金鑰。由於這兩層加密都套用到伺服器端的物件，因此您可以使用各種 AWS 服務 和 工具來分析 S3 中的資料，同時使用可滿足多層加密合規要求的加密方法。如需詳細資訊，請參閱[使用雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)](UsingDSSEncryption.md)。
**使用客戶提供金鑰 (SSE-C) 的伺服器端加密**
使用「伺服器端加密搭配客戶提供金鑰 (SSE-C)」時，您負責管理加密金鑰，而 Amazon S3 會在將物件寫入磁碟時進行加密，並在您存取物件時予以解密。如需詳細資訊，請參閱[搭配客戶提供的金鑰 (SSE-C) 使用伺服器端加密](ServerSideEncryptionCustomerKeys.md)。
**注意**
使用 S3 存取點將存取點用於 Amazon FSx 檔案系統時，您可以選擇伺服器端加密。
所有 Amazon FSx 檔案系統預設都已設定加密，並使用 管理的金鑰進行靜態加密 AWS Key Management Service。當資料寫入檔案系統並從檔案系統讀取時，資料會在檔案系統上自動加密和解密。這些程序由 Amazon FSx 以透明化方式處理。
# 對 Amazon S3 儲存貯體設定預設伺服器端加密行為
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
根據預設，所有 Amazon S3 儲存貯體皆已設定加密，且使用伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 自動加密物件。此加密設定適用於 Amazon S3 儲存貯體中的所有物件。
如果您需要更多控制金鑰，例如管理金鑰輪換和存取政策授予，您可以選擇使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 或雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)。如需詳細了解編輯 KMS 金鑰，請參閱《AWS Key Management Service 開發人員指南》**中的[編輯金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/editing-keys.html)。
**注意**
我們已變更儲存貯體，以自動加密新物件上傳。若您之前建立的儲存貯體沒有預設加密，根據預設，Amazon S3 會使用 SSE-S3 為儲存貯體啟用加密。對於已設定 SSE-S3 或 SSE-KMS 的現有儲存貯體，預設加密設定不會有任何變更。若您想要使用 SSE-KMS 加密物件，則必須變更儲存貯體設定中的加密類型。如需詳細資訊，請參閱[搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。
當您將儲存貯體設定為搭配 SSE-KMS 使用預設加密時，您也可以啟用 S3 儲存貯體金鑰，以減少從 Amazon S3 到 的請求流量， AWS KMS 並降低加密成本。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
若要識別已啟用 SSE-KMS 進行預設加密的儲存貯體，您可以使用 Amazon S3 Storage Lens 指標。S3 Storage Lens 是一種雲端儲存體分析功能，您可以用來了解整個組織使用物件儲存體的情況及其活動情形。如需詳細資訊，請參閱[使用 S3 Storage Lens 保護資料](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-lens-data-protection.html?icmpid=docs_s3_user_guide_bucket-encryption.html)。
當您使用伺服器端加密時，Amazon S3 會在將物件儲存到磁碟之前加密，並在下載物件時解密。如需使用伺服器端加密與加密金鑰管理來保護資料的詳細資訊，請參閱 [使用伺服器端加密保護資料](serv-side-encryption.md)。
如需預設加密所需許可的詳細資訊，請參閱《Amazon Simple Storage Service API 參考》**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)。
您可以使用 Amazon S3 主控台、 AWS SDKs、Amazon S3 REST API 和 AWS 命令列界面 () 來設定 S3Amazon S3 儲存貯體的 Amazon S3 預設加密行為AWS CLI。
**加密現有物件**
若要加密現有的未加密 Amazon S3 物件，您可以使用 Amazon S3 批次操作。請提供 S3 批次作業可操作的物件清單，批次作業就會呼叫個別 API 來執行指定的操作。您可以使用[批次操作複製操作](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-copy-object.html)來複製現有的未加密物件，並將其作為加密物件寫入相同的儲存貯體中。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章《[使用 Amazon S3 批次操作加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)》。
您也可以使用 `CopyObject` API 操作或 `copy-object` AWS CLI 命令來加密現有的物件。如需詳細資訊，請參閱 *AWS 儲存部落格*文章《[使用 AWS CLI加密現有的 Amazon S3 物件](https://aws.amazon.com/blogs/storage/encrypting-existing-amazon-s3-objects-with-the-aws-cli/)》。
**注意**
如果 Amazon S3 儲存貯體的預設儲存貯體加密為 SSE-KMS，則不能作為 [使用伺服器存取記錄記錄要求](ServerLogs.md) 的目的地儲存貯體。伺服器存取日誌目標儲存貯體僅支援 SSE-S3 預設加密。
## 針對跨帳戶操作使用 SSE-KMS 加密
對跨帳戶操作使用加密時，請注意下列事項：
+ 如果未在請求時間或透過儲存貯體的預設加密組態提供 AWS KMS key Amazon Resource Name (ARN) 或別名，則會使用 AWS 受管金鑰 (`aws/s3`)。
+ 如果您使用 AWS 帳戶 與 KMS 金鑰位於相同 的 AWS Identity and Access Management (IAM) 主體來上傳或存取 S3 物件，您可以使用 AWS 受管金鑰 (`aws/s3`)。
+ 如果您想要授予 S3 物件跨帳戶存取權，請使用客戶受管金鑰。您可以設定客戶受管金鑰的政策，以允許從另一個帳戶存取的權限。
+ 指定客戶自管 KMS 金鑰時，建議您使用完整的 KMS 金鑰 ARN。如果您改為使用 KMS 金鑰別名， 會在申請者的帳戶中 AWS KMS 解析金鑰。此行為可能會導致資料使用屬於申請者 (而不是儲存貯體擁有者) 的 KMS 金鑰來加密。
+ 您必須指定已授予您 (要求者) 已獲授予 `Encrypt` 許可的金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[允許金鑰使用者在密碼編譯操作中使用 KMS 金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-users-crypto)。
如需何時使用客戶受管金鑰和 AWS 受管 KMS 金鑰的詳細資訊，請參閱[我應該使用 AWS 受管金鑰 或客戶受管金鑰來加密 Amazon S3 中的物件嗎？](https://aws.amazon.com/premiumsupport/knowledge-center/s3-object-encryption-keys/)
## 搭配使用預設加密與複寫
在您啟用域複寫目的地儲存貯體的預設加密之後，適用下列加密行為：
+ 如果未加密來源儲存貯體中的物件，則會使用目的地儲存貯體的預設加密設定來加密目的地儲存貯體中的複本物件。因此，來源物件的實體標籤 (ETag) 與複本物件的 ETag 不同。如果您有使用 ETag 的應用程式，則必須更新這些應用程式以解決此差異。
+ 如果透過使用伺服器端加密搭配 Amazon S3 受管金鑰 (SSE-S3)、伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 或雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS) 來加密來源儲存貯體中的物件，則目的地儲存貯體中的複本物件會使用與來源物件相同的加密類型。不會使用目的地儲存貯體的預設加密設定。
如需搭配 SSE-KMS 使用預設加密的詳細資訊，請參閱[複寫加密的物件](replication-config-for-kms-objects.md)。
## 搭配使用 Amazon S3 儲存貯體金鑰和預設加密
當您將儲存貯體設定為在新物件上使用 SSE-KMS 做為預設加密行為時，您還可以設定 S3 儲存貯體金鑰。S3 儲存貯體金鑰可將 Amazon S3 的交易數量減少為 AWS KMS ，以降低 SSE-KMS 的成本。
當您將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰時， AWS KMS 會產生儲存貯體層級金鑰，用於為儲存貯體中的物件建立唯一的[資料金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)。此 S3 儲存貯體金鑰在 Amazon S3 內使用一段時間，減少 Amazon S3 向 提出請求 AWS KMS 以完成加密操作的需求。
如需使用 S3 儲存貯體金鑰的詳細資訊，請參閱 [使用 Amazon S3 儲存貯體金鑰](bucket-key.md)。
# 設定預設加密
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
根據預設，Amazon S3 儲存貯體皆已啟動儲存貯體加密，且使用伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 自動加密新物件。此加密免費適用於 Amazon S3 儲存貯體中的所有新物件。
如果您需要更多對加密金鑰的控制，例如管理金鑰輪換和存取政策授予，您可以選擇使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 或雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)。如需 SSE-KMS 的詳細資訊，請參閱「[使用 AWS KMS (SSE-KMS) 指定伺服器端加密](specifying-kms-encryption.md)」。如需 DSSE-KMS 的詳細資訊，請參閱 [使用雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)](UsingDSSEncryption.md)。
若您想要使用其他帳戶的 KMS 金鑰，您必須具有該金鑰的使用權限。如需詳細了解 KMS 金鑰跨帳戶權限，請參閱《AWS Key Management Service 開發人員指南》**中的[建立其他帳戶可使用的 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)。
當您將預設儲存貯體加密設定為 SSE-KMS 時，您也可以設定 S3 儲存貯體金鑰來降低 AWS KMS 請求成本。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
**注意**
如果您使用 [PutBucketEncryption](https://docs.aws.amazon.com//AmazonS3/latest/API/API_PutBucketEncryption.html) 將預設儲存貯體加密設定為 SSE-KMS，則應驗證您的 KMS 金鑰 ID 正確無誤。Amazon S3 不會驗證 PutBucketEncryption 請求中提供的 KMS 金鑰 ID。
使用 S3 儲存貯體的預設加密不需要額外收費。請求設定預設加密行為會產生標準 Amazon S3 請求費用。如需定價的資訊，請參閱 [Amazon S3 定價](https://aws.amazon.com/s3/pricing/)。對於 SSE-KMS 和 DSSE-KMS，需支付 AWS KMS 費用，並按[AWS KMS 定價](https://aws.amazon.com/kms/pricing/)列出。
不支援使用客戶所提供金鑰 (SSE-C) 的伺服器端加密做為預設加密。
您可以使用 Amazon S3 主控台、 AWS SDKs、Amazon S3 REST API 和 AWS Command Line Interface () 來S3Amazon S3 儲存貯體的 Amazon S3 預設加密AWS CLI。
**啟用預設加密之前，應注意的變更**
在您啟用儲存貯體的預設加密之後，適用下列加密行為：
+ 在啟用預設加密之前，不會變更儲存貯體中現有物件的加密。
+ 在啟用預設加密之後上傳物件時：
+ 如果您的 `PUT` 請求標題未包含加密資訊，則 Amazon S3 會使用儲存貯體的預設加密設定來加密物件。
+ 如果您的 `PUT` 請求標題包含加密資訊，則 Amazon S3 會先使用 `PUT` 請求中的加密資訊來加密物件，再將物件存放至 Amazon S3。
+ 如果您針對預設加密組態使用 SSE-KMS 或 DSSE-KMS 選項，則受到 AWS KMS的每秒請求數目 (RPS) 配額限制。如需 AWS KMS 配額以及如何請求提高配額的詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[配額](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)。
**注意**
在啟用預設加密之前上傳的物件不會受到加密。如需詳細了解加密現有物件，請參閱 [對 Amazon S3 儲存貯體設定預設伺服器端加密行為](bucket-encryption.md)。
## 使用 S3 主控台
**設定 Amazon S3 儲存貯體的預設加密**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您所需的儲存貯體名稱。
1. 選擇**屬性**索引標籤。
1. 在 **Default encryption (預設加密)** 底下，選擇 **Edit (編輯)**。
1. 若要設定加密，請在**加密類型**下，選擇下列其中一項：
+ **使用 Amazon S3 受管金鑰 (SSE-S3) 的伺服器端加密**
+ **伺服器端加密與 AWS Key Management Service 金鑰 (SSE-KMS)**
+ **使用 AWS Key Management Service 金鑰進行雙層伺服器端加密 (DSSE-KMS)**
**重要**
如果您針對預設加密組態使用 SSE-KMS 或 DSSE-KMS 選項，則受到 AWS KMS的每秒請求數目 (RPS) 配額限制。如需 AWS KMS 配額以及如何請求提高配額的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[配額](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)。
除非您為儲存貯體指定其他類型的預設加密，否則根據預設，儲存貯體和新物件皆會使用 SSE-S3 加密。如需預設加密的詳細資訊，請參閱[對 Amazon S3 儲存貯體設定預設伺服器端加密行為](bucket-encryption.md)。
如需有關使用 Amazon S3 伺服器端加密來加密資料的詳細資訊，請參閱「[使用 Amazon S3 受管金鑰 (SSE-S3) 進行伺服器端加密](UsingServerSideEncryption.md)」。
1. 如果您選擇**使用 AWS Key Management Service 金鑰的伺服器端加密 (SSE-KMS)** 或**使用 AWS Key Management Service 金鑰的雙層伺服器端加密 (DSSE-KMS)**，請執行下列動作：
1. 在 **AWS KMS 金鑰**下，使用下列其中一種方式指定 KMS 金鑰：
+ 若要從可用的 KMS 金鑰清單中選擇，請選擇**從中選擇 AWS KMS keys**，然後從可用的金鑰清單中選擇您的 **KMS** 金鑰。
AWS 受管金鑰 (`aws/s3`) 和您的客戶受管金鑰都會顯示在此清單中。如需客戶受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
+ 若要輸入 KMS 金鑰 ARN，請選擇**輸入 AWS KMS key ARN**，然後在出現的欄位中輸入您的 KMS 金鑰 ARN。
+ 若要在 AWS KMS 主控台中建立新的客戶受管金鑰，請選擇**建立 KMS 金鑰**。
如需建立 的詳細資訊 AWS KMS key，請參閱《 *AWS Key Management Service 開發人員指南*》中的[建立金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)。
**重要**
您只能使用 AWS 區域 在與儲存貯體相同的 中啟用的 KMS 金鑰。如果選擇的是 **Choose from your KMS keys** (從您的 KMS 金鑰選擇)，則 S3 主控台只會列出每個區域的其中 100 個 KMS 金鑰。如果您在相同區域中有超過 100 個 KMS 金鑰，您只能看到 S3 主控台中的前 100 個 KMS 金鑰。若要使用主控台中未列出的 KMS 金鑰，請選擇**輸入 AWS KMS key ARN**，然後輸入 KMS 金鑰 ARN。
當您在 Amazon S3 中使用 AWS KMS key 進行伺服器端加密時，您必須選擇對稱加密 KMS 金鑰。Amazon WorkMail 只支援對稱加密 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
如需有關搭配 Amazon S3 使用 SSE-KMS 的詳細資訊，請參閱 [搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。如需 DSSE-KMS 的使用詳細資訊，請參閱 [使用雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)](UsingDSSEncryption.md)。
1. 當您將儲存貯體設定為使用 SSE-KMS 的預設加密時，您還可以啟用 S3 儲存貯體金鑰。S3 儲存貯體金鑰透過減少來自 Amazon S3 的請求流量來降低加密成本 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
若要使用 S3 儲存貯體金鑰，在 **Bucket Key (儲存貯體金鑰)** 下選擇 **Enable (啟用)**。
**注意**
DSSE-KMS 不支援 S3 儲存貯體金鑰。
1. 選擇**儲存變更**。
## 使用 AWS CLI
這些範例說明如何使用 SSE-S3 或具有 S3 儲存貯體金鑰的 SSE-KMS 來設定預設加密。
如需預設加密的詳細資訊，請參閱[對 Amazon S3 儲存貯體設定預設伺服器端加密行為](bucket-encryption.md)。如需使用 AWS CLI 設定預設加密的詳細資訊，請參閱 [put-bucket-encryption](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-bucket-encryption.html)。
**Example – 使用 SSE-S3 預設加密**
此範例會使用 Amazon S3 受管金鑰設定預設儲存貯體加密。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
}
}
]
}'
```
**Example – 使用 S3 儲存貯體金鑰以 SSE-KMS 預設加密**
此範例會使用 S3 儲存貯體金鑰，以 SSE-KMS 設定預設儲存貯體加密。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "aws:kms",
"KMSMasterKeyID": "KMS-Key-ARN"
},
"BucketKeyEnabled": true
}
]
}'
```
## 使用 REST API
使用 REST API `PutBucketEncryption` 操作來啟用預設加密，以及設定要使用的伺服器端加密類型 (SSE-S3、SSE-KMS 或 DSSE-KMS)。
如需詳細資訊，請參閱 Amazon Simple Storage Service API 參考**中的 [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTBucketPUTencryption.html)。
# 使用 AWS CloudTrail 和 Amazon EventBridge 監控預設加密
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
您可以使用 AWS CloudTrail 事件追蹤 Amazon S3 儲存貯體的預設加密組態請求。CloudTrail 日誌使用下列 API 事件名稱：
+ `PutBucketEncryption`
+ `GetBucketEncryption`
+ `DeleteBucketEncryption`
您也可以建立 EventBridge 規則，以符合這些 API 呼叫的 CloudTrail 事件。如需 CloudTrail 事件的詳細資訊，請參閱「[使用主控台啟用儲存貯體中物件的記錄](enable-cloudtrail-logging-for-s3.md#enable-cloudtrail-events)」。如需 EventBridge 事件的詳細資訊，請參閱[來自 的事件 AWS 服務](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-service-event.html)。
您可以針對物件層級的 Amazon S3 動作使用 CloudTrail 日誌來追蹤對 Amazon S3 的 `PUT` 和 `POST` 要求。當傳入 `PUT` 要求沒有加密標頭時，您可以使用這些動作來驗證是否使用預設加密來加密物件。
當 Amazon S3 使用預設加密設定來加密物件時，日誌會包含以下其中一個名稱-值對的欄位：`"SSEApplied":"Default_SSE_S3"`、`"SSEApplied":"Default_SSE_KMS"` 或 `"SSEApplied":"Default_DSSE_KMS"`。
當 Amazon S3 使用 `PUT` 加密標頭來加密物件時，日誌會包含以下名稱-值對的欄位之一：`"SSEApplied":"SSE_S3"`、`"SSEApplied":"SSE_KMS"`、`"SSEApplied":"DSSE_KMS"` 或 `"SSEApplied":"SSE_C"`。
針對分段上傳，此資訊會包含在 `InitiateMultipartUpload` API 操作要求中。如需有關使用 CloudTrail 與 CloudWatch 的詳細資訊，請參閱[在 Amazon S3 中記錄和監控](monitoring-overview.md)。
# 預設加密常見問答集
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。使用 256 位元進階加密標準 (AES-256) 的 SSE-S3 會自動套用至所有新的儲存貯體，以及套用至任何尚未設定預設加密的現有 S3 儲存貯體。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 AWS CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS Command Line Interface (AWS CLI) 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。
以下各節回答有關此更新的問題。
**Amazon S3 是否會針對已設定預設加密的現有儲存貯體變更預設加密設定？**
否。已設定 SSE-S3 或伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 的現有儲存貯體的預設加密組態沒有變更。如需如何設定儲存貯體預設加密行為的詳細資訊，請參閱 [對 Amazon S3 儲存貯體設定預設伺服器端加密行為](bucket-encryption.md)。如需 SSE-S3 和 SSE-KMS 加密設定的詳細資訊，請參閱 [使用伺服器端加密保護資料](serv-side-encryption.md)。
**是否會在未設定預設加密的現有儲存貯體上啟用預設加密？**
是。Amazon S3 現在可在所有現有未加密的儲存貯體上設定預設加密，套用伺服器端加密與 S3 受管金鑰 (SSE-S3)，作為上傳至這些儲存貯體之新物件的基本加密層級。已存在於現有未加密儲存貯體中的物件將不會自動加密。
**如何檢視新物件上傳的預設加密狀態？**
目前，您可以在 AWS CloudTrail 日誌、S3 清查和 S3 Storage Lens、Amazon S3 主控台，以及 AWS Command Line Interface (AWS CLI) 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中，檢視新物件上傳的預設加密狀態。
+ 若要檢視您的 CloudTrail 事件，請參閱《AWS CloudTrail 使用者指南》**中的[在 CloudTrail 主控台中檢視 CloudTrail 事件](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events-console.html)。CloudTrail 日誌會針對 Amazon S3 提供 API 追蹤 `PUT` 和 `POST` 請求。當預設加密用來加密儲存貯體中的物件時，`PUT` 和 `POST` API 請求中的 CloudTrail 日誌將包含以下欄位作為名稱/值對：`"SSEApplied":"Default_SSE_S3"`。
+ 若要檢視 S3 清查中新物件上傳的自動加密狀態，請將 S3 清查報告設定為包含 **Encryption** (加密) 的中繼資料欄位，然後在報告中查看每個新物件的加密狀態。如需詳細資訊，請參閱[設定 Amazon S3 清查](https://docs.aws.amazon.com/AmazonS3/latest/userguide/configure-inventory.html#storage-inventory-setting-up)。
+ 若要檢視 S3 Storage Lens 中新物件上傳的自動加密狀態，請設定 S3 Storage Lens 儀表板，並在儀表板的 **Data protection** (資料保護) 類別中查看 **Encrypted bytes** (加密位元組) 和 **Encrypted object count** (加密物件計數) 指標。如需詳細資訊，請參閱[使用 S3 主控台](storage_lens_creating_dashboard.md#storage_lens_console_creating)及[在儀表板上檢視 S3 Storage Lens 指標](storage_lens_view_metrics_dashboard.md)。
+ 若要在 Amazon S3 主控台中檢視儲存貯體層級的自動加密狀態，請在 Amazon S3 主控台中檢查 Amazon S3 儲存貯體的**預設加密**。如需詳細資訊，請參閱[設定預設加密](default-bucket-encryption.md)。
+ 若要在 AWS Command Line Interface (AWS CLI) 和 AWS SDKs 中將自動加密狀態檢視為額外的 Amazon S3 API 回應標頭，請在使用 [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) 和 [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) 等物件動作 APIs `x-amz-server-side-encryption`時檢查回應標頭。
**我必須做什麼才能利用此變更？**
您不需要對現有的應用程式進行任何變更。因為您的所有儲存貯體都已啟用預設加密，所有上傳到 Amazon S3 的新物件都會自動加密。
**是否可以針對寫入至儲存貯體的新物件停用加密？**
否。SSE-S3 是新的加密基本層級，適用於所有要上載至儲存貯體的新物件。您再也無法停用新物件上傳的加密。
**我的費用是否會受到影響嗎？**
否。搭配 SSE-S3 的預設加密可免費使用。我們會照常向您收取儲存、請求和其他 S3 功能的費用。如需定價，請參閱 [Amazon S3 定價](https://aws.amazon.com/s3/pricing/)。
**Amazon S3 是否會加密現有未加密的物件？**
否。從 2023 年 1 月 5 日開始，Amazon S3 只會自動加密新物件上傳。若要加密現有物件，您可以使用 S3 Batch Operations 來建立物件的加密複本。這些加密複本將保留現有的物件資料和名稱，並將使用您指定的加密金鑰加密。如需詳細資訊，請參閱《AWS 儲存體部落格》**中的[使用 Amazon S3 Batch Operations 加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)。
**在此版本之前，我並未針對儲存貯體啟用加密。我是否需要變更存取物件的方式？**
否。搭配 SSE-S3 的預設加密會在資料寫入 Amazon S3 時自動加密該資料，並在您存取該資料時為您將其解密。您存取自動加密物件的方式沒有變更。
**我是否需要變更存取用戶端加密物件的方式？**
否。上傳到 Amazon S3 之前已加密的所有用戶端加密物件都會在 Amazon S3 內以加密的密文物件形式送達。這些物件現在將會有另一層 SSE-S3 加密。使用用戶端加密物件的工作負載不需要對用戶端服務或授權設定進行任何變更。
**注意**
未使用更新版本 AWS 提供者的 HashiCorp Terraform 使用者可能會在建立沒有客戶定義加密組態的新 S3 儲存貯體之後看到非預期的偏離。若要避免此偏離，請將您的 Terraform AWS Provider 版本更新為下列其中一個版本：任何4.x版本、 3.76.1或 2.70.4。
# 更新現有資料的伺服器端加密
根據預設，所有 Amazon S3 儲存貯體皆已設定加密，且使用伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 自動加密物件。此預設加密設定適用於 Amazon S3 儲存貯體中的所有新物件。
使用 `UpdateObjectEncryption` API 操作，您可以將一般用途儲存貯體中現有加密物件的伺服器端加密類型從使用 Amazon S3 受管加密 (SSE-S3) 的伺服器端加密更新為使用 AWS Key Management Service (AWS KMS) 加密金鑰 (SSE-KMS) 的伺服器端加密。`UpdateObjectEncryption` API 操作使用[信封加密](https://docs.aws.amazon.com/kms/latest/developerguide/kms-cryptography.html#enveloping)來重新加密用來使用新指定的伺服器端加密類型來加密和解密物件的資料金鑰。
Amazon S3 會在沒有任何資料移動的情況下執行此加密類型更新。換言之，當您使用 `UpdateObjectEncryption`操作時，您的資料不會複製、不會還原 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive 中的封存物件，也不會在層之間移動 S3 Intelligent-Tiering 儲存類別中的物件。此外， `UpdateObjectEncryption`操作會保留所有物件中繼資料屬性，包括儲存類別、建立日期、上次修改日期、ETag 和檢查總和屬性。
一般用途儲存貯體支援的所有 S3 儲存類別都支援`UpdateObjectEncryption`此操作。您可以使用 `UpdateObjectEncryption`操作來執行下列動作：
+ 使用 Amazon S3 受管加密 (SSE-S3) 將加密物件從伺服器端加密變更為使用 AWS Key Management Service (AWS KMS) 加密金鑰 (SSE-KMS) 的伺服器端加密。
+ 更新物件層級 SSE-KMS 加密物件以使用 S3 儲存貯體金鑰，這會減少從 Amazon S3 到 的 AWS KMS 請求流量 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
+ 變更用於加密資料的客戶受管 KMS 金鑰，以便您符合自訂金鑰輪換標準。
**注意**
此操作不支援未加密或使用 AWS KMS keys (DSSE-KMS) 或客戶提供加密金鑰 (SSE-C) 進行雙層伺服器端加密的來源物件。
無論物件的大小或儲存類別為何，`UpdateObjectEncryption`操作通常會以毫秒完成，包括 S3 Glacier Flexible Retrieval 或 S3 Glacier Deep Archive。此操作不會計入 S3 Intelligent-Tiering 的存取權，因此如果您變更物件的伺服器端加密類型，不常存取層或 Archive Instant Access 層中的物件不會自動分層回經常存取層。
`UpdateObjectEncryption` 是一種物件層級 （資料平面） API 操作，會記錄到 Amazon S3 伺服器存取日誌和 AWS CloudTrail 資料事件。如需詳細資訊，請參閱[Amazon S3 的記錄選項](logging-with-S3.md)。
`UpdateObjectEncryption` 操作的定價與 `PUT`、`POST`、 `COPY`和 `LIST`請求 （每 1，000 個請求） 相同，無論基礎物件的儲存類別為何，一律以 S3 標準儲存類別請求計費。如需詳細資訊，請參閱 [Simple Storage Service (Amazon S3) 定價](https://aws.amazon.com/s3/pricing/)。
## 限制與考量事項
使用 `UpdateObjectEncryption`操作時，適用下列限制和考量事項：
+ `UpdateObjectEncryption` 此操作不支援未加密的物件，或使用 (DSSE-KMS) 或客戶提供的加密金鑰 (SSE-C) 進行 AWS KMS keys 雙層伺服器端加密的物件。此外，您無法將 SSE-S3 指定為請求的新加密類型`UpdateObjectEncryption`請求。
+ 您可以使用 `UpdateObjectEncryption`操作來更新已啟用 S3 版本控制的儲存貯體中的物件。若要更新特定版本的加密類型，您必須在`UpdateObjectEncryption`請求中指定版本 ID。如果您未指定版本 ID，`UpdateObjectEncryption`請求會作用於物件的目前版本。如需 S3 版本控制的詳細資訊，請參閱「[使用 S3 版本控制保留多個版本的物件](Versioning.md)」。
+ `UpdateObjectEncryption` 操作會在套用 S3 物件鎖定保留模式或法務保存的任何物件上失敗。如果物件具有控管模式保留期間或法務保存，您必須先移除物件上的物件鎖定狀態，才能發出`UpdateObjectEncryption`請求。您無法對套用物件鎖定合規模式保留期的物件使用 `UpdateObjectEncryption`操作。如需 S3 物件鎖定的詳細資訊，請參閱[使用物件鎖定來鎖定物件](object-lock.md)。
+ `UpdateObjectEncryption` 已啟用即時複寫的來源儲存貯體請求不會在目的地儲存貯體中啟動複本事件。如果您想要變更來源和目的地儲存貯體中物件的加密類型，則必須對來源和目的地儲存貯體中的物件啟動個別`UpdateObjectEncryption`的請求。
+ 根據預設，指定客戶受管 KMS 金鑰的所有`UpdateObjectEncryption`請求僅限於儲存貯體擁有者 擁有的 KMS 金鑰 AWS 帳戶。如果您使用的是 AWS Organizations，您可以透過聯絡 來請求使用組織內其他成員帳戶 AWS KMS keys 擁有的功能 AWS 支援。
+ 如果您使用 S3 批次複寫跨區域複寫資料集，且您的物件先前已將其伺服器端加密類型從 SSE-S3 更新為 SSE-KMS，您可能需要額外的許可。在來源區域儲存貯體上，您必須擁有 `kms:decrypt` 許可。然後，您將需要目的地區域中儲存貯體的 `kms:decrypt`和 `kms:encrypt`許可。
+ 您必須在`UpdateObjectEncryption`請求中提供完整的 KMS 金鑰 ARN。您無法使用別名名稱或別名 ARN。您可以在 AWS KMS 主控台或使用 AWS KMS `DescribeKey` API 來判斷完整的 KMS 金鑰 ARN。
## 所需的許可
若要執行 `UpdateObjectEncryption`操作，您必須具有下列許可：
+ `s3:PutObject`
+ `s3:UpdateObjectEncryption`
+ `kms:Encrypt`
+ `kms:Decrypt`
+ `kms:GenerateDataKey`
+ `kms:ReEncrypt*`
如果您使用的是 AWS Organizations，若要將此操作與 AWS 帳戶 組織內其他 的客戶受管 KMS 金鑰搭配使用，您必須擁有 `organizations:DescribeAccount`許可。您還必須聯絡 ，請求能夠使用組織內其他成員帳戶 AWS KMS keys 擁有的功能 AWS 支援。
若要執行 `UpdateObjectEncryption`操作，請將下列 AWS Identity and Access Management (IAM) 政策新增至您的 IAM 角色。若要使用此政策，請將 取代`amzn-s3-demo-bucket`為一般用途儲存貯體的名稱，並將另一個取代`user input placeholders`為您自己的資訊。
```
{
"Version": "2012-10-17",
"Statement": [{
"Sid": "AllowUpdateObjectEncryption",
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:UpdateObjectEncryption",
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey",
"kms:ReEncrypt*",
"organizations:DescribeAccount"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:kms:us-east-1:111122223333:key/01234567-89ab-cdef-0123-456789abcdef"
]
}
]
}
```
## 大量更新加密
若要透過單一請求更新多個 Amazon S3 物件的伺服器端加密類型，您可以使用 S3 批次操作。您可以向 S3 Batch Operations 提供要操作的物件清單，也可以指示 Batch Operations 產生以物件清單為基礎的物件中繼資料，包括字首、儲存類別、建立日期、加密類型、KMS 金鑰 ARN 或 S3 儲存貯體金鑰狀態。S3 批次操作會呼叫相應的 API 操作來執行指定操作。單一批次操作任務可以對包含 PB 資料之儲存貯體中的數十億個物件執行指定的操作。如需批次作業的詳細資訊，請參閱「[使用 Batch Operations 大量執行物件操作](batch-ops.md)」。
S3 Batch Operations 功能會追蹤進度、傳送通知，並存放所有動作的詳細完成報告，提供完整受管、可稽核、無伺服器的體驗。您可以透過 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI) AWS SDKs 或 Amazon S3 REST API 使用 S3 批次操作。 Amazon S3 如需詳細資訊，請參閱[更新物件加密](batch-ops-update-encryption.md)。
## 更新物件的加密
您可以透過 AWS Command Line Interface (AWS CLI) AWS SDKs伺服器端加密類型。 Amazon S3
### 更新物件的加密
#### 使用 AWS CLI
若要執行下列命令，您必須 AWS CLI 安裝並設定 。如果您尚未 AWS CLI 安裝 ，請參閱*AWS Command Line Interface 《 使用者指南*》中的[安裝或更新至最新版本的 AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/getting-started-install.html) 。
或者，您也可以使用 ，從主控台執行 AWS CLI 命令 AWS CloudShell。 AWS CloudShell 是一種以瀏覽器為基礎的預先驗證 Shell，您可以直接從 啟動 AWS 管理主控台。如需詳細資訊，請參閱《AWS CloudShell 使用者指南》**中的[什麼是 CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/welcome.html) 和[開始使用 AWS CloudShell](https://docs.aws.amazon.com//cloudshell/latest/userguide/getting-started.html)。
**使用 更新物件的加密 AWS CLI**
若要使用下列範例命令，請以您自己的資訊取代 `user input placeholders`。
1. 使用下列命令來更新一般用途儲存貯體中單一物件 (`index.html`) 的加密 （例如 `amzn-s3-demo-bucket`)，以搭配 S3 儲存貯體金鑰使用 SSE-KMS：
```
aws s3api update-object-encryption \
--bucket amzn-s3-demo-bucket \
--key index.html \
--object-encryption '{"SSEKMS": { "KMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/f12a345a-678e-9bbb-1025-62e317037583", "BucketKeyEnabled": true }}'
```
**注意**
您必須指定完整的 AWS KMS key Amazon Resource Name (ARN)。不支援 KMS 金鑰 ID 和 KMS 金鑰別名。
1. 執行 `head-object`命令以檢視物件的更新加密類型：
```
aws s3api head-object --bucket amzn-s3-demo-bucket --key index.html
```
#### 使用 REST API
您可以傳送 REST 請求來更新物件的加密。如需詳細資訊，請參閱[https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateObjectEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateObjectEncryption.html)。
#### 使用 AWS SDKs
您可以使用 AWS SDKs來更新物件的加密。如需詳細資訊，請參閱[支援的 SDKs 清單](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateObjectEncryption.html#API_UpdateObjectEncryption_SeeAlso)。
------
#### [ Java ]
**Example**
下列 AWS SDK for Java 2.x 範例會將一般用途儲存貯體中物件的加密類型更新為 SSE-KMS。
```
public void updateObjectEncryption(String bucketName,
String objectKey,
String versionId,
String kmsKeyArn,
boolean bucketKeyEnabled) {
// Create the target object encryption type.
ObjectEncryption objectEncryption = ObjectEncryption.builder()
.ssekms(SSEKMSEncryption.builder()
.kmsKeyArn(kmsKeyArn)
.bucketKeyEnabled(bucketKeyEnabled)
.build())
.build();
// Create the UpdateObjectEncryption request.
UpdateObjectEncryptionRequest request = UpdateObjectEncryptionRequest.builder()
.bucket(bucketName)
.key(objectKey)
.versionId(versionId)
.objectEncryption(objectEncryption)
.build();
// Update the object encryption.
try {
getS3Client().updateObjectEncryption(request);
logger.info("Object encryption updated to SSE-KMS for {} in bucket {}", objectKey, bucketName);
} catch (S3Exception e) {
logger.error("Failed to update to object encryption: {} - Error code: {}", e.awsErrorDetails().errorMessage(),
e.awsErrorDetails().errorCode());
throw e;
}
}
```
------
#### [ Python ]
**Example**
下列 適用於 Python (Boto3) 的 AWS SDK 範例顯示如何將一般用途儲存貯體中物件的加密類型更新為 SSE-KMS。
```
response = client.update_object_encryption(
Bucket='string',
Key='string',
VersionId='string',
ObjectEncryption={
'SSEKMS': {
'KMSKeyArn': 'string',
'BucketKeyEnabled': True|False
}
}
)
```
------
# 使用 Amazon S3 受管金鑰 (SSE-S3) 進行伺服器端加密
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
所有上傳到 Amazon S3 儲存貯體的新物件均會使用伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 進行加密。
伺服器端加密保護靜態資料。Amazon S3 會使用不重複的金鑰加密每個物件。它使用定期輪換的金鑰自行加密金鑰，提供額外的防護。Amazon S3 伺服器端加密使用 256 位元 Galois/計數器模式中的進階加密標準 (AES-GCM) 來加密所有上傳的物件。
將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 搭配使用不需另外付費。不過，請求設定預設加密功能會產生標準 Amazon S3 請求費用。如需定價的資訊，請參閱 [Amazon S3 定價](https://aws.amazon.com/s3/pricing/)。
若您希望上傳的資料僅使用 Amazon S3 受管金鑰加密，您可以使用下列儲存貯體政策。例如，除非要求包含 `x-amz-server-side-encryption`標頭以要求伺服器端加密，否則以下儲存貯體政策會拒絕上傳物件的許可權限：
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "DenyObjectsThatAreNotSSES3",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "AES256"
}
}
}
]
}
```
------
**注意**
伺服器端加密只會加密物件資料，非物件中繼資料。
## 伺服器端加密的 API 支援
根據預設，所有 Amazon S3 儲存貯體都設定了加密，所有上傳到 S3 儲存貯體的新物件都會在靜態時自動加密。伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 是 Amazon S3 中每個儲存貯體的預設加密組態。若要使用不同類型的加密，您可以指定 S3 `PUT` 請求中要使用的伺服器端加密類型，也可以在目的地儲存貯體中更新預設加密組態。
如果您想要在`PUT`請求中指定不同的加密類型，您可以使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)、雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)，或伺服器端加密搭配客戶提供的金鑰 (SSE-C)。若您想在目的地儲存貯體中設定不同的預設加密組態，您可以使用 SSE-KMS 或 DSSE-KMS。
如需變更一般用途儲存貯體之預設加密組態的詳細資訊，請參閱 [設定預設加密](default-bucket-encryption.md)。
當您將儲存貯體的預設加密組態變更為 SSE-KMS 時，並不會變更儲存貯體中現有 Amazon S3 物件的加密類型。若要在將預設加密組態更新為 SSE-KMS 之後變更既有物件的加密類型，您可以使用 Amazon S3 Batch Operations。您為 S3 Batch Operations 提供物件清單，而批次操作會呼叫個別 API 操作。您可以使用 [複製物件](batch-ops-copy-object.md) 動作來複製現有物件，該動作會將它們寫回與 SSE-KMS 加密物件相同的儲存貯體。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章[如何使用 S3 庫存清單、Amazon Athena 和 S3 Batch Operations 來追溯加密 Amazon S3 中的現有物件](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)。
若要使用物件建立 REST API，用以設定伺服器端加密，請務必提供 `x-amz-server-side-encryption` 要求標頭。如需 REST APIs 的相關資訊，請參閱[使用 REST API](specifying-s3-encryption.md#SSEUsingRESTAPI)。
下列 Amazon S3 API 支援此標頭。
+ **PUT 操作** — 使用 `PUT` API 上傳資料時，請指定要求標頭。如需詳細資訊，請參閱 [PUT 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)。
+ **啟動分段上傳** — 使用分段上傳 API 操作上傳大型物件時，您可於起始要求時，指定這些標頭。如需詳細資訊，請參閱[啟動分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)。
+ **COPY 操作** — 當您複製物件時，要有來源物件與目標物件。如需詳細資訊，請參閱 [PUT 物件 - 複製](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)。
**注意**
使用 `POST` 操作上傳物件時，請您提供與表單欄位中相同的資訊，而非提供要求標頭。如需詳細資訊，請參閱 [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)。
AWS SDKs 也提供包裝函式 APIs，您可以用來請求伺服器端加密。您也可以使用 AWS 管理主控台 上傳物件並請求伺服器端加密。
如需更多一般資訊，請參閱《AWS Key Management Service 開發人員指南》**中的 [AWS KMS 概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html)。
**Topics**
+ [
## 伺服器端加密的 API 支援
](#APISupportforServer-SideEncryption)
+ [
# 使用 Amazon S3 受管金鑰 (SSE-S3) 指定伺服器端加密
](specifying-s3-encryption.md)
# 使用 Amazon S3 受管金鑰 (SSE-S3) 指定伺服器端加密
根據預設，所有 Amazon S3 儲存貯體都設定了加密，所有上傳到 S3 儲存貯體的新物件都會在靜態時自動加密。伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 是 Amazon S3 中每個儲存貯體的預設加密組態。若要使用不同類型的加密，您可以指定 S3 `PUT` 請求中要使用的伺服器端加密類型，也可以在目的地儲存貯體中更新預設加密組態。
如果您想要在`PUT`請求中指定不同的加密類型，您可以使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)、雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)，或伺服器端加密搭配客戶提供的金鑰 (SSE-C)。若您想在目的地儲存貯體中設定不同的預設加密組態，您可以使用 SSE-KMS 或 DSSE-KMS。
如需變更一般用途儲存貯體之預設加密組態的詳細資訊，請參閱 [設定預設加密](default-bucket-encryption.md)。
當您將儲存貯體的預設加密組態變更為 SSE-KMS 時，並不會變更儲存貯體中現有 Amazon S3 物件的加密類型。若要在將預設加密組態更新為 SSE-KMS 之後變更既有物件的加密類型，您可以使用 Amazon S3 Batch Operations。您為 S3 Batch Operations 提供物件清單，而批次操作會呼叫個別 API 操作。您可以使用 [複製物件](batch-ops-copy-object.md) 動作來複製現有物件，該動作會將它們寫回與 SSE-KMS 加密物件相同的儲存貯體。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章[如何使用 S3 庫存清單、Amazon Athena 和 S3 Batch Operations 來追溯加密 Amazon S3 中的現有物件](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)。
您可以使用 SSE-S33 AWS CLI。 APIs AWS SDKs AWS Command Line Interface 如需詳細資訊，請參閱[對 Amazon S3 儲存貯體設定預設伺服器端加密行為](bucket-encryption.md)。
## 使用 S3 主控台
本主題說明如何使用 AWS 管理主控台設定或變更物件所使用的加密類型。當您使用主控台複製物件時，Amazon S3 會依原樣複製物件。這表示，若來源物件已加密，則目標物件也會加密。您可以使用主控台來新增或變更物件的加密。
**注意**
如果您的物件小於 5 GB，您可以變更物件的加密。如果您的物件大於 5 GB，您必須使用 [AWS CLI](mpu-upload-object.md#UsingCLImpUpload) 或 [AWS SDK](CopyingObjectsMPUapi.md) 來變更物件的加密。
如需變更物件加密所需的其他許可清單，請參閱[Amazon S3 API 操作所需的許可](using-with-s3-policy-actions.md)。如需授予此許可的範例政策，請參閱[Amazon S3 的身分型政策範例](example-policies-s3.md)。
如果您變更物件的加密，則會建立新物件來取代舊物件。如果啟用 S3 版本控制，則系統會建立物件的新版本，且現有物件會變成較舊的版本。變更屬性的角色也會成為新物件 (或物件版本) 的擁有者。
**變更物件的加密**
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在導覽窗格中，選擇**儲存貯體**，然後選擇**一般用途儲存貯體**索引標籤。導覽至包含您要變更之物件的 Amazon S3 儲存貯體或資料夾。
1. 選取您要變更之物件的核取方塊。
1. 從**動作**功能表上顯示的選項清單中，選擇**編輯伺服器端加密**。
1. 捲動至**伺服器端加密**區段。
1. 在**加密設定**底下，選擇**使用預設加密的儲存貯體設定**或**覆寫預設加密的儲存貯體設定**。
1. 若您選擇**覆寫預設加密的儲存貯體設定**，請設定下列加密設定。
1. 在**加密類型**下，選擇**使用 Amazon S3 受管金鑰的伺服器端加密 (SSE-S3)**。SSE-S3 使用目前最強大的其中一種區塊加密法，也就是 256 位元進階加密標準 (AES-256)，來加密每個物件。如需詳細資訊，請參閱[使用 Amazon S3 受管金鑰 (SSE-S3) 進行伺服器端加密](UsingServerSideEncryption.md)。
1. 在**其他複製設定**下，選擇**複製來源設定**、**不要指定設定**或**指定設定**。**複製來源設定**是預設選項。如果您只想複製物件但不想包含來源設定屬性，請選擇**不要指定設定**。選擇**指定設定**以指定儲存類別、ACL、物件標籤、中繼資料、伺服器端加密和額外檢查總和的設定。
1. 選擇 **Save changes** (儲存變更)。
**注意**
此動作會將加密套用至所有指定的物件。加密資料夾時，請等待儲存作業完成，然後再將新物件新增至資料夾。
## 使用 REST API
建立物件時 (也就是當您上傳新的物件或複製現有物件時)，可以指定是否在請求中新增 `x-amz-server-side-encryption` 標頭，讓 Amazon S3 以 Amazon S3 受管金鑰 (SSE-S3) 加密您的資料。將標頭值設為 Amazon S3 支援的加密演算法 `AES256`。Amazon S3 會傳回回應標頭 `x-amz-server-side-encryption`，確認已使用 SSE-S3 存放物件。
下列 REST 上傳 API 操作，接受 `x-amz-server-side-encryption` 要求標頭。
+ [PUT 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT 物件 - 複製](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [啟動分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
使用分段上傳 API 操作上傳大型物件時，可以對啟動分段上傳要求新增 `x-amz-server-side-encryption` 標頭，指定伺服器端加密。複製現有物件時，除非明確地要求伺服器端加密，否則無論來源物件是否經過加密，都不會加密目標物件。
使用 SSE-S3 存放物件時，下列 REST API 操作的回應標頭會傳回 `x-amz-server-side-encryption` 標頭。
+ [PUT 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)
+ [PUT 物件 - 複製](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectCOPY.html)
+ [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [啟動分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)
+ [上傳片段](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)
+ [上傳片段 - 複製](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)
+ [完成分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadComplete.html)
+ [Get 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)
+ [Head 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)
**注意**
如果物件使用 SSE-S3，請勿為 `GET` 請求與 `HEAD` 請求傳送加密請求標頭，否則您會收到 HTTP 狀態碼 400 (錯誤的請求) 錯誤。
## 使用 AWS SDKs
使用 AWS SDKs時，您可以請求 Amazon S3 搭配 Amazon S3 受管加密金鑰 (SSE-S3) 使用伺服器端加密。本節提供以多種語言使用 AWS SDKs的範例。如需其他 SDK 的資訊，請前往[範例程式碼與程式庫](https://aws.amazon.com/code)。
------
#### [ Java ]
當您使用 適用於 Java 的 AWS SDK 上傳物件時，您可以使用 SSE-S3 來加密物件。若要求伺服器端加密，可使用 `ObjectMetadata`，`PutObjectRequest`的屬性，設定 `x-amz-server-side-encryption` 要求標頭。當您呼叫 `AmazonS3Client` 的，`putObject()` 方法時，Amazon S3 會加密和儲存資料。
使用分段上傳 API 操作時，您也可以要求 SSE-S3 加密。
+ 使用高階分段上傳 API 操作，您可以使用 `TransferManager` 方法，應用於上傳伺服器端物件加密。您可使用任一接受 `ObjectMetadata` 為參數的上傳方法。如需詳細資訊，請參閱[使用分段上傳來上傳物件](mpu-upload-object.md)。
+ 使用低階分段上傳 API 操作，可以在啟動分段上傳時，指定伺服器端加密。呼叫 `ObjectMetadata` 的方法，新增 `InitiateMultipartUploadRequest.setObjectMetadata()` 屬性。如需詳細資訊，請參閱[使用 AWS SDKs（低階 API)](mpu-upload-object.md#mpu-upload-low-level)。
您無法直接更改物件的加密狀態 (加密未加密的物件或解密加密的物件)。要更改物件的加密狀態，請複製該物件，指定所需複本的加密狀態，然後刪除原始物件。只有在您明確請求伺服器端加密時，Amazon S3 才會加密複製的物件。使用 `ObjectMetadata` 屬性，在 `CopyObjectRequest` 中透過 API 指定伺服器端加密，要求進行物件複本加密。
**Example 範例**
下列範例示範如何使用 適用於 Java 的 AWS SDK設定伺服器端加密。說明如何執行以下任務：
+ 使用 SSE-S3 上傳新物件。
+ 透過製作物件複本，更改物件的加密狀態 (在此範例中，加密先前未加密過的物件)。
+ 確認物件加密狀態。
如需伺服器端加密的詳細資訊，請參閱「[使用 REST API](#SSEUsingRESTAPI)」。如需建立和測試工作範例的說明，請參閱《 適用於 Java 的 AWS SDK 開發人員指南》中的[入門](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html)。
```
import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.internal.SSEResultBase;
import com.amazonaws.services.s3.model.*;
import java.io.ByteArrayInputStream;
public class SpecifyServerSideEncryption {
public static void main(String[] args) {
Regions clientRegion = Regions.DEFAULT_REGION;
String bucketName = "*** Bucket name ***";
String keyNameToEncrypt = "*** Key name for an object to upload and encrypt ***";
String keyNameToCopyAndEncrypt = "*** Key name for an unencrypted object to be encrypted by copying ***";
String copiedObjectKeyName = "*** Key name for the encrypted copy of the unencrypted object ***";
try {
AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
.withRegion(clientRegion)
.withCredentials(new ProfileCredentialsProvider())
.build();
// Upload an object and encrypt it with SSE.
uploadObjectWithSSEEncryption(s3Client, bucketName, keyNameToEncrypt);
// Upload a new unencrypted object, then change its encryption state
// to encrypted by making a copy.
changeSSEEncryptionStatusByCopying(s3Client,
bucketName,
keyNameToCopyAndEncrypt,
copiedObjectKeyName);
} catch (AmazonServiceException e) {
// The call was transmitted successfully, but Amazon S3 couldn't process
// it, so it returned an error response.
e.printStackTrace();
} catch (SdkClientException e) {
// Amazon S3 couldn't be contacted for a response, or the client
// couldn't parse the response from Amazon S3.
e.printStackTrace();
}
}
private static void uploadObjectWithSSEEncryption(AmazonS3 s3Client, String bucketName, String keyName) {
String objectContent = "Test object encrypted with SSE";
byte[] objectBytes = objectContent.getBytes();
// Specify server-side encryption.
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setContentLength(objectBytes.length);
objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName,
new ByteArrayInputStream(objectBytes),
objectMetadata);
// Upload the object and check its encryption status.
PutObjectResult putResult = s3Client.putObject(putRequest);
System.out.println("Object \"" + keyName + "\" uploaded with SSE.");
printEncryptionStatus(putResult);
}
private static void changeSSEEncryptionStatusByCopying(AmazonS3 s3Client,
String bucketName,
String sourceKey,
String destKey) {
// Upload a new, unencrypted object.
PutObjectResult putResult = s3Client.putObject(bucketName, sourceKey, "Object example to encrypt by copying");
System.out.println("Unencrypted object \"" + sourceKey + "\" uploaded.");
printEncryptionStatus(putResult);
// Make a copy of the object and use server-side encryption when storing the
// copy.
CopyObjectRequest request = new CopyObjectRequest(bucketName,
sourceKey,
bucketName,
destKey);
ObjectMetadata objectMetadata = new ObjectMetadata();
objectMetadata.setSSEAlgorithm(ObjectMetadata.AES_256_SERVER_SIDE_ENCRYPTION);
request.setNewObjectMetadata(objectMetadata);
// Perform the copy operation and display the copy's encryption status.
CopyObjectResult response = s3Client.copyObject(request);
System.out.println("Object \"" + destKey + "\" uploaded with SSE.");
printEncryptionStatus(response);
// Delete the original, unencrypted object, leaving only the encrypted copy in
// Amazon S3.
s3Client.deleteObject(bucketName, sourceKey);
System.out.println("Unencrypted object \"" + sourceKey + "\" deleted.");
}
private static void printEncryptionStatus(SSEResultBase response) {
String encryptionStatus = response.getSSEAlgorithm();
if (encryptionStatus == null) {
encryptionStatus = "Not encrypted with SSE";
}
System.out.println("Object encryption status is: " + encryptionStatus);
}
}
```
------
#### [ .NET ]
當您上傳物件時，可指示 Amazon S3 加密物件。若要變更現有物件的加密狀態，請複製該物件並刪除來源物件。依預設值，除非您明確地要求對目標物件進行伺服器端加密，否則複製作業不會加密目標。若要在 `CopyObjectRequest` 中指定 SSE-S3，請新增下列項目：
```
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
```
如需如何複製物件的工作範例，請參閱「[使用 AWS SDKs](copy-object.md#CopyingObjectsUsingSDKs)」。
下列範例會上傳一個物件。在請求中，此範例會指示 Amazon S3 加密物件。然後，示範擷取物件中繼資料，驗證使用的加密方法。如需有關設定和執行程式碼範例的資訊，請參閱《[適用於 .NET 的 AWS SDK 開發人員指南》中的適用於 .NET 的 SDK 入門](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)。 *AWS *
```
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Threading.Tasks;
namespace Amazon.DocSamples.S3
{
class SpecifyServerSideEncryptionTest
{
private const string bucketName = "*** bucket name ***";
private const string keyName = "*** key name for object created ***";
// Specify your bucket region (an example region is shown).
private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
private static IAmazonS3 client;
public static void Main()
{
client = new AmazonS3Client(bucketRegion);
WritingAnObjectAsync().Wait();
}
static async Task WritingAnObjectAsync()
{
try
{
var putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = keyName,
ContentBody = "sample text",
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AES256
};
var putResponse = await client.PutObjectAsync(putRequest);
// Determine the encryption state of an object.
GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = keyName
};
GetObjectMetadataResponse response = await client.GetObjectMetadataAsync(metadataRequest);
ServerSideEncryptionMethod objectEncryption = response.ServerSideEncryptionMethod;
Console.WriteLine("Encryption method used: {0}", objectEncryption.ToString());
}
catch (AmazonS3Exception e)
{
Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message);
}
catch (Exception e)
{
Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
}
}
}
}
```
------
#### [ PHP ]
本主題說明如何使用 第 3 版的類別 適用於 PHP 的 AWS SDK ，將 SSE-S3 新增至您上傳至 Amazon S3 的物件。如需適用於 Ruby 的 AWS SDK API 的詳細資訊，請前往[AWS 適用於 Ruby 的 SDK - 第 2 版](https://docs.aws.amazon.com/sdkforruby/api/index.html)。
若要將物件上傳至 Amazon S3，請使用 [Aws\$1S3\$1S3Client::putObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#putobject) 方法。若要將 `x-amz-server-side-encryption` 請求標頭新增至上傳請求，則需使用 `AES256` 值來指定 `ServerSideEncryption` 參數，如以下程式碼範例所示。如需伺服器端加密要求的詳細資訊，請參閱[使用 REST API](#SSEUsingRESTAPI)。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
// $filepath should be an absolute path to a file on disk.
$filepath = '*** Your File Path ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Upload a file with server-side encryption.
$result = $s3->putObject([
'Bucket' => $bucket,
'Key' => $keyname,
'SourceFile' => $filepath,
'ServerSideEncryption' => 'AES256',
]);
```
在回應時，Amazon S3 會傳回 `x-amz-server-side-encryption` 標頭，值為用來加密物件資料的加密演算法。
當您使用分段上傳 API 操作上傳大型物件時，可以為要上傳的物件指定 SSE-S3，如下所示：
+ 如果使用低階分段上傳 API 操作，請在呼叫 [ Aws\$1S3\$1S3Client::createMultipartUpload()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) 方法時指定伺服器端加密。若要將 `x-amz-server-side-encryption` 請求標頭新增至請求，則需使用 `AES256` 值來指定 `array` 參數的 `ServerSideEncryption` 金鑰。如需低階分段上傳 API 操作的詳細資訊，請參閱 [使用 AWS SDKs（低階 API)](mpu-upload-object.md#mpu-upload-low-level)。
+ 使用高階分段上傳 API 操作時，請使用 [CreateMultipartUpload](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#createmultipartupload) API 操作的 `ServerSideEncryption` 參數來指定伺服器端加密。如需使用 `setOption()` 方法搭配高階分段上傳 API 操作的範例，請參閱 [使用分段上傳來上傳物件](mpu-upload-object.md)。
若要判斷現有物件的加密狀態，請呼叫 [Aws\$1S3\$1S3Client::headObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#headobject) 方法來擷取物件中繼資料，如下列 PHP 程式碼範例所示。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$bucket = '*** Your Bucket Name ***';
$keyname = '*** Your Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Check which server-side encryption algorithm is used.
$result = $s3->headObject([
'Bucket' => $bucket,
'Key' => $keyname,
]);
echo $result['ServerSideEncryption'];
```
若要變更現有物件的加密狀態，請使用 [Aws\$1S3\$1S3Client::copyObject()](https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-s3-2006-03-01.html#copyobject) 方法建立物件複本，並刪除原始物件。除非您使用值為 `AES256` 的 `ServerSideEncryption` 參數來明確請求目的地物件的伺服器端加密，否則 `copyObject()` 預設不會加密目標。下列 PHP 程式碼範例會建立物件複本，並將伺服器端加密新增至複製的物件。
```
require 'vendor/autoload.php';
use Aws\S3\S3Client;
$sourceBucket = '*** Your Source Bucket Name ***';
$sourceKeyname = '*** Your Source Object Key ***';
$targetBucket = '*** Your Target Bucket Name ***';
$targetKeyname = '*** Your Target Object Key ***';
$s3 = new S3Client([
'version' => 'latest',
'region' => 'us-east-1'
]);
// Copy an object and add server-side encryption.
$s3->copyObject([
'Bucket' => $targetBucket,
'Key' => $targetKeyname,
'CopySource' => "$sourceBucket/$sourceKeyname",
'ServerSideEncryption' => 'AES256',
]);
```
如需詳細資訊，請參閱下列主題：
+ [適用於 PHP 的 AWS SDK 適用於 Amazon S3 Aws\$1S3\$1S3Client 類別](https://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.S3.S3Client.html)
+ [適用於 PHP 的 AWS SDK 文件](https://aws.amazon.com/documentation/sdk-for-php/)
------
#### [ Ruby ]
使用 適用於 Ruby 的 AWS SDK 上傳物件時，您可以指定使用 SSE-S3 儲存靜態加密的物件。當您讀回物件時，會自動解密。
下列第 3 適用於 Ruby 的 AWS SDK 版範例示範如何指定靜態加密上傳至 Amazon S3 的檔案。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectPutSseWrapper
attr_reader :object
# @param object [Aws::S3::Object] An existing Amazon S3 object.
def initialize(object)
@object = object
end
def put_object_encrypted(object_content, encryption)
@object.put(body: object_content, server_side_encryption: encryption)
true
rescue Aws::Errors::ServiceError => e
puts "Couldn't put your content to #{object.key}. Here's why: #{e.message}"
false
end
end
# Example usage:
def run_demo
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-encrypted-content"
object_content = "This is my super-secret content."
encryption = "AES256"
wrapper = ObjectPutSseWrapper.new(Aws::S3::Object.new(bucket_name, object_content))
return unless wrapper.put_object_encrypted(object_content, encryption)
puts "Put your content into #{bucket_name}:#{object_key} and encrypted it with #{encryption}."
end
run_demo if $PROGRAM_NAME == __FILE__
```
下列程式碼範例示範如何判斷現有物件的加密狀態。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectGetEncryptionWrapper
attr_reader :object
# @param object [Aws::S3::Object] An existing Amazon S3 object.
def initialize(object)
@object = object
end
# Gets the object into memory.
#
# @return [Aws::S3::Types::GetObjectOutput, nil] The retrieved object data if successful; otherwise nil.
def object
@object.get
rescue Aws::Errors::ServiceError => e
puts "Couldn't get object #{@object.key}. Here's why: #{e.message}"
end
end
# Example usage:
def run_demo
bucket_name = "amzn-s3-demo-bucket"
object_key = "my-object.txt"
wrapper = ObjectGetEncryptionWrapper.new(Aws::S3::Object.new(bucket_name, object_key))
obj_data = wrapper.get_object
return unless obj_data
encryption = obj_data.server_side_encryption.nil? ? 'no' : obj_data.server_side_encryption
puts "Object #{object_key} uses #{encryption} encryption."
end
run_demo if $PROGRAM_NAME == __FILE__
```
若存放在 Amazon S3 的物件未使用伺服器端加密，該方法會傳回 `null`。
若要變更現有物件的加密狀態，請複製物件並刪除來源物件。根據預設，除非明確地要求進行伺服器端加密，否則複製方法依預設不會加密目標。您可以在雜湊引數選項中指定 `server_side_encryption` 值，以此請求加密目標物件，如下列 Ruby 程式碼範例所示。該程式碼範例示範如何以 SSE-S3 複製物件及加密複本。
```
require 'aws-sdk-s3'
# Wraps Amazon S3 object actions.
class ObjectCopyEncryptWrapper
attr_reader :source_object
# @param source_object [Aws::S3::Object] An existing Amazon S3 object. This is used as the source object for
# copy actions.
def initialize(source_object)
@source_object = source_object
end
# Copy the source object to the specified target bucket, rename it with the target key, and encrypt it.
#
# @param target_bucket [Aws::S3::Bucket] An existing Amazon S3 bucket where the object is copied.
# @param target_object_key [String] The key to give the copy of the object.
# @return [Aws::S3::Object, nil] The copied object when successful; otherwise, nil.
def copy_object(target_bucket, target_object_key, encryption)
@source_object.copy_to(bucket: target_bucket.name, key: target_object_key, server_side_encryption: encryption)
target_bucket.object(target_object_key)
rescue Aws::Errors::ServiceError => e
puts "Couldn't copy #{@source_object.key} to #{target_object_key}. Here's why: #{e.message}"
end
end
# Example usage:
def run_demo
source_bucket_name = "amzn-s3-demo-bucket1"
source_key = "my-source-file.txt"
target_bucket_name = "amzn-s3-demo-bucket2"
target_key = "my-target-file.txt"
target_encryption = "AES256"
source_bucket = Aws::S3::Bucket.new(source_bucket_name)
wrapper = ObjectCopyEncryptWrapper.new(source_bucket.object(source_key))
target_bucket = Aws::S3::Bucket.new(target_bucket_name)
target_object = wrapper.copy_object(target_bucket, target_key, target_encryption)
return unless target_object
puts "Copied #{source_key} from #{source_bucket_name} to #{target_object.bucket_name}:#{target_object.key} and "\
"encrypted the target with #{target_object.server_side_encryption} encryption."
end
run_demo if $PROGRAM_NAME == __FILE__
```
------
## 使用 AWS CLI
若要在使用 上傳物件時指定 SSE-S3 AWS CLI，請使用下列範例。
```
aws s3api put-object --bucket amzn-s3-demo-bucket1 --key object-key-name --server-side-encryption AES256 --body file path
```
如需詳細資訊，請參閱 *AWS CLI 參考*中的 [put-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/put-object.html)。若要在使用 複製物件時指定 SSE-S3 AWS CLI，請參閱 [copy-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/copy-object.html)。
## 使用 CloudFormation
如需使用 設定加密的範例 CloudFormation，請參閱*AWS CloudFormation 《 使用者指南*》中的使用伺服器端加密搭配 S3 儲存貯體金鑰範例[建立具有預設加密](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_with_default_encryption)`AWS::S3::Bucket ServerSideEncryptionRule`的儲存貯體和建立儲存貯體。 [AWS KMS S3 ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html#aws-properties-s3-bucket-serversideencryptionrule--examples--Create_a_bucket_using_AWS_KMS_server-side_encryption_with_an_S3_Bucket_Key)
# 搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)
**重要**
Amazon S3 現在將伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 套用為 Amazon S3 中每個儲存貯體的基本加密層級。從 2023 年 1 月 5 日起，所有上傳到 Amazon S3 的新物件都會自動加密，無需額外費用，也不會影響效能。S3 儲存貯體預設加密組態和新物件上傳的自動加密狀態可在 CloudTrail 日誌、S3 庫存、S3 Storage Lens、Amazon S3 主控台，以及 AWS CLI 和 AWS SDKs 中的其他 Amazon S3 API 回應標頭中使用。如需詳細資訊，請參閱[預設加密常見問答集](https://docs.aws.amazon.com/AmazonS3/latest/userguide/default-encryption-faq.html)。
伺服器端加密是指接收資料的應用程式或服務在目的地將資料加密。
Amazon S3 會自動為新上傳的物件，以 Amazon S3 受管金鑰 (SSE-S3) 啟用伺服器端加密。
除非您另行指定，否則根據預設，儲存貯體會使用 SSE-S3 來加密物件。不過，您可以選擇將儲存貯體設定為使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)。如需詳細資訊，請參閱[使用 AWS KMS (SSE-KMS) 指定伺服器端加密](specifying-kms-encryption.md)。
AWS KMS 是一種服務，結合了安全、高可用性的硬體和軟體，以提供針對雲端擴展的金鑰管理系統。Amazon S3 使用伺服器端加密搭配 AWS KMS (SSE-KMS) 來加密 S3 物件資料。此外，當物件請求 SSE-KMS 時，S3 檢查總和 (作為物件中繼資料的一部分) 會以加密形式儲存。如需總和檢查的詳細資訊，請參閱 [在 Amazon S3 中檢查物件完整性](checking-object-integrity.md)。
如果您使用 KMS 金鑰，您可以透過 AWS KMS [AWS 管理主控台](https://console.aws.amazon.com/kms)或 [AWS KMS API](https://docs.aws.amazon.com/kms/latest/APIReference/) 使用 來執行下列動作：
+ 集中建立、檢視、編輯、監控、啟用或停用、輪換和排程 KMS 金鑰的刪除。
+ 定義可控制 KMS 金鑰使用方式和使用者的政策。
+ 稽核 KMS 金鑰用量以正確使用。[AWS KMS API](https://docs.aws.amazon.com/kms/latest/APIReference/) 支援稽核，但 [AWS KMS Console;](https://console.aws.amazon.com/kms) 不支援。
中的安全控制 AWS KMS 可協助您符合加密相關的合規要求。您可以使用這些 KMS 金鑰來保護 Amazon S3 儲存貯體中的資料。當您搭配 S3 儲存貯體使用 SSE-KMS 加密時， AWS KMS keys 必須與儲存貯體位於相同的區域。
使用 需支付額外費用 AWS KMS keys。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的 [AWS KMS key 概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys)和 [AWS KMS 定價](https://aws.amazon.com/kms/pricing)。
如需允許 IAM 使用者存取 KMS 加密儲存貯體的指示，請參閱 [My Amazon S3 儲存貯體具有使用自訂 AWS KMS 金鑰的預設加密。如何允許使用者從 下載並上傳至儲存貯體？](https://repost.aws/knowledge-center/s3-bucket-access-default-encryption) AWS re:Post 知識中心的 。
**許可**
若要成功向 Amazon S3 提出使用 AWS KMS 金鑰加密物件的 `PutObject` 請求，您需要金鑰的 `kms:GenerateDataKey` 許可。若要下載使用 加密的物件 AWS KMS key，您需要 金鑰的`kms:Decrypt`許可。若要[執行分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html#mpuAndPermissions)以使用 加密物件 AWS KMS key，您必須擁有 金鑰的 `kms:GenerateDataKey`和 `kms:Decrypt`許可。
**重要**
請仔細檢閱 KMS 金鑰政策中授予的許可。一律將客戶受管 KMS 金鑰政策許可限制為必須存取相關 AWS KMS 金鑰動作的 IAM 主體 AWS 和服務。如需詳細資訊，請參閱 [中的金鑰政策 AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)。
**Topics**
+ [
## AWS KMS keys
](#aws-managed-customer-managed-keys)
+ [
## Amazon S3 儲存貯體金鑰
](#sse-kms-bucket-keys)
+ [
## 要求伺服器端加密
](#require-sse-kms)
+ [
## 加密內容
](#encryption-context)
+ [
## 傳送 AWS KMS 加密物件的請求
](#aws-signature-version-4-sse-kms)
+ [
# 使用 AWS KMS (SSE-KMS) 指定伺服器端加密
](specifying-kms-encryption.md)
+ [
# 使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本
](bucket-key.md)
## AWS KMS keys
當您搭配 AWS KMS (SSE-KMS) 使用伺服器端加密時，您可以使用預設的 [AWS 受管金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)，也可以指定您已建立[的客戶受管金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk)。 AWS KMS 支援*信封加密*。S3 使用*信封加密* AWS KMS 功能來進一步保護您的資料。封套加密是使用資料金鑰來加密純文字資料，然後再透過另一個 KMS 金鑰來加密資料金鑰的實務做法。如需封套加密的詳細資訊，請參閱 *AWS Key Management Service 開發人員指南*中的[封套加密](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#enveloping)。
如果您未指定客戶受管金鑰，Amazon S3 會在您 AWS 帳戶 第一次將以 SSE-KMS 加密的物件新增至儲存貯 AWS 受管金鑰 體時自動建立 。根據預設，Amazon S3 會將此 KMS 金鑰用於 SSE-KMS。
**注意**
使用 SSE-KMS 搭配 [AWS 受管金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk) 加密的物件無法跨帳戶共用。如果您需要跨帳戶共用 SSE-KMS 資料，您必須從中使用[客戶受管金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) AWS KMS。
如果您想要針對 SSE-KMS 使用客戶受管金鑰，請在設定 SSE-KMS 之前建立對稱加密客戶受管金鑰。然後，當您為儲存貯體設定 SSE-KMS 時，請指定現有客戶受管金鑰。如需對稱加密的詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
建立客戶受管金鑰可為您提供更多的靈活性與控制。例如，您可以建立、輪換和停用客戶受管金鑰。您也可以定義存取控制，並稽核用來保護資料的客戶受管金鑰。如需客戶受管金鑰和 AWS 受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
**注意**
當您搭配存放在外部金鑰存放區中的客戶受管金鑰使用伺服器端加密時，與標準 KMS 金鑰不同，您有責任確保金鑰材料的可用性和耐久性。如需外部金鑰存放區及其如何轉移共用責任模型的詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[外部金鑰存放區](https://docs.aws.amazon.com//kms/latest/developerguide/keystore-external.html)。
### 針對跨帳戶操作使用 SSE-KMS 加密
對跨帳戶操作使用加密時，請注意下列事項：
+ 如果未在請求時間或透過儲存貯體的預設加密組態提供 AWS KMS key Amazon Resource Name (ARN) 或別名， AWS 受管金鑰 則會使用上傳帳戶中的 (`aws/s3`) 進行加密和解密。
+ AWS 受管金鑰 當上傳和存取 (IAM`aws/s3`) 主體來自相同 時， AWS Identity and Access Management () 可以用作跨帳戶操作的 KMS 金鑰 AWS 帳戶。
+ 如果您想要授予 S3 物件跨帳戶存取權，請使用客戶受管金鑰。您可以設定客戶受管金鑰的政策，以允許從另一個帳戶存取的權限。
+ 指定客戶自管 KMS 金鑰時，建議您使用完整的 KMS 金鑰 ARN。如果您改用 KMS 金鑰別名， 會在申請者的帳戶中 AWS KMS 解析金鑰。此行為可能會導致資料使用屬於申請者 (而不是儲存貯體擁有者) 的 KMS 金鑰來加密。
+ 您必須指定已授予您 (要求者) 已獲授予 `Encrypt` 許可的金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[允許金鑰使用者在密碼編譯操作中使用 KMS 金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-users-crypto)。
如需何時使用客戶受管金鑰和 AWS 受管 KMS 金鑰的詳細資訊，請參閱[我應該使用 AWS 受管金鑰 或客戶受管金鑰來加密 Amazon S3 中的物件嗎？](https://aws.amazon.com/premiumsupport/knowledge-center/s3-object-encryption-keys/)
### SSE-KMS 加密工作流程
如果您選擇使用 AWS 受管金鑰 或客戶受管金鑰加密資料， AWS KMS Amazon S3 會執行下列信封加密動作：
1. Amazon S3 請求純文字[資料金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#data-keys)和在指定的 KMS 金鑰下加密的金鑰複本。
1. AWS KMS 會產生資料金鑰、在 KMS 金鑰下加密，並將純文字資料金鑰和加密的資料金鑰同時傳送至 Amazon S3。
1. Amazon S3 使用資料金鑰來加密資料，並在使用後盡快從記憶體中移除純文字金鑰。
1. Amazon S3 將加密的資料金鑰以中繼資料形式跟加密資料一起存放。
當您請求解密您的資料時，Amazon S3 會 AWS KMS 執行下列動作：
1. Amazon S3 會在`Decrypt`請求 AWS KMS 中將加密的資料金鑰傳送至 。
1. AWS KMS 使用相同的 KMS 金鑰解密加密的資料金鑰，並將純文字資料金鑰傳回 Amazon S3。
1. Amazon S3 使用純文字資料金鑰來解密加密的資料，然後盡快從記憶體移除純文字資料金鑰。
**重要**
當您在 Amazon S3 中使用 AWS KMS key 進行伺服器端加密時，您必須選擇對稱加密 KMS 金鑰。Amazon S3 只支援對稱加密 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
### 稽核 SSE-KMS 加密
若要識別指定 SSE-KMS 的請求，您可以在 Amazon S3 Storage Lens 指標中使用**所有 SSE-KMS 請求**和 **% 所有 SSE-KMS 請求**指標。S3 Storage Lens 是一種雲端儲存體分析功能，您可以用來了解整個組織使用物件儲存體的情況及其活動情形。您也可以使用啟用 SSE-KMS 的儲存貯體計數和啟用 SSE-KMS 的儲存貯體百分比，來了解[預設儲存貯體加密](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html) (SSE-KMS) 的儲存貯體計數。如需詳細資訊，請參閱[使用 S3 Storage Lens 評估儲存活動和用量](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens.html?icmpid=docs_s3_user_guide_UsingKMSEncryption.html)。如需完整的指標清單，請參閱 [S3 Storage Lens 指標詞彙表](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage_lens_metrics_glossary.html?icmpid=docs_s3_user_guide_UsingKMSEncryption.html)。
若要稽核 SSE-KMS 加密資料的 AWS KMS 金鑰使用情況，您可以使用 AWS CloudTrail 日誌。您可以深入了解[密碼編譯操作](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#cryptographic-operations)，例如 [https://docs.aws.amazon.com/kms/latest/developerguide/ct-generatedatakey.html](https://docs.aws.amazon.com/kms/latest/developerguide/ct-generatedatakey.html) 和 [https://docs.aws.amazon.com/kms/latest/developerguide/ct-decrypt.html](https://docs.aws.amazon.com/kms/latest/developerguide/ct-decrypt.html)。CloudTrail 支援多種[屬性值](https://docs.aws.amazon.com/awscloudtrail/latest/APIReference/API_LookupEvents.html)來篩選搜尋，包括事件名稱、使用者名稱和事件來源。
## Amazon S3 儲存貯體金鑰
當您使用 AWS KMS (SSE-KMS) 設定伺服器端加密時，您可以將儲存貯體設定為使用 SSE-KMS 的 S3 儲存貯體金鑰。使用 SSE-KMS 的儲存貯體層級金鑰，可將 Amazon S3 的 AWS KMS 請求流量降低高達 99% 的請求成本 AWS KMS。
當您將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰時， AWS KMS 會產生一個儲存貯體層級金鑰，用於為儲存貯體中的物件建立唯一的[資料金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)。此 S3 儲存貯體金鑰在 Amazon S3 內使用一段時間，進一步減少 Amazon S3 向 提出請求 AWS KMS 以完成加密操作的需求。如需使用 S3 儲存貯體金鑰的詳細資訊，請參閱 [使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
## 要求伺服器端加密
若要在特定 Amazon S3 儲存貯體中要求所有物件的伺服器端加密，您可以使用儲存貯體政策。例如，如果請求不包含要求含 SSE-KMS 之伺服器端加密的 `x-amz-server-side-encryption-aws-kms-key-id` 標頭，則下列儲存貯體政策會拒絕向所有人上傳物件 (`s3:PutObject`) 的許可。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id":"PutObjectPolicy",
"Statement":[{
"Sid":"DenyObjectsThatAreNotSSEKMS",
"Effect":"Deny",
"Principal":"*",
"Action":"s3:PutObject",
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket1/*",
"Condition":{
"Null":{
"s3:x-amz-server-side-encryption-aws-kms-key-id":"true"
}
}
}
]
}
```
------
若要要求 AWS KMS key 使用特定 來加密儲存貯體中的物件，您可以使用 `s3:x-amz-server-side-encryption-aws-kms-key-id`條件金鑰。若要指定 KMS 金鑰，您必須使用 `arn:aws:kms:region:acct-id:key/key-id` 格式的金鑰 Amazon Resource Name (ARN)。 AWS Identity and Access Management 不會驗證 `s3:x-amz-server-side-encryption-aws-kms-key-id` 的字串是否存在。
**注意**
當您上傳物件時，您可以使用 `x-amz-server-side-encryption-aws-kms-key-id` 標頭或依賴您的[預設儲存貯體加密組態](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html)來指定 KMS 金鑰。如果您的 PutObject 請求在 `x-amz-server-side-encryption` 標頭中指定 `aws:kms`，但未指定 `x-amz-server-side-encryption-aws-kms-key-id` 標頭，則 Amazon S3 會假設您想要使用 AWS 受管金鑰。無論如何，Amazon S3 用於物件加密的 AWS KMS 金鑰 ID 必須符合政策中的 AWS KMS 金鑰 ID，否則 Amazon S3 會拒絕請求。
如需 Amazon S3 特定條件索引鍵的完整清單，請參閱服務授權參考**中的 [Amazon S3 的條件索引鍵](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html#amazons3-policy-keys)。
## 加密內容
*加密內容*是一組金鑰值對，其中包含資料的其他相關內容資訊。加密內容不被加密。為加密操作指定加密內容時，Amazon S3 必須指定與解密操作相同的加密內容。否則，解密失敗。 AWS KMS 會使用加密內容做為[額外的驗證資料](https://docs.aws.amazon.com/database-encryption-sdk/latest/devguide/concepts.html#digital-sigs) (AAD)，以支援[驗證加密](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#cryptographic-operations#digital-sigs)。如需有關加密內容的詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[加密內容](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)。
根據預設，Amazon S3 會使用物件或儲存貯體 Amazon Resource Name (ARN) 作為加密內容對：
+ **如果在未啟用 S3 儲存貯體金鑰的情況下使用 SSE-KMS**，則使用物件 ARN 作為加密內容。
```
arn:aws:s3:::object_ARN
```
+ **如果使用 SSE-KMS 並啟用 S3 儲存貯體金鑰**，則使用儲存貯體 ARN 作為加密內容。如需 S3 儲存貯體金鑰的詳細資訊，請參閱 [使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
```
arn:aws:s3:::bucket_ARN
```
您可以選擇在 [s3:PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html#API_PutObject_RequestSyntax) 請求中使用 `x-amz-server-side-encryption-context` 標頭，來提供其他加密內容對。不過，加密內容未加密，因此請確保其中不包含敏感資訊。Amazon S3 會一起存放此附加金鑰對與預設加密內容。當其處理 `PUT` 請求時，Amazon S3 會將 `aws:s3:arn` 的預設加密內容附加至您提供的加密內容。
您可以使用加密內容來識別和分類密碼編譯操作。您也可以使用預設加密內容 ARN 值， AWS CloudTrail 透過檢視搭配哪個加密金鑰使用的 Amazon S3 ARN，在 中追蹤相關請求。
在 CloudTrail 日誌檔案的 `requestParameters` 欄位中，加密內容看起來如下。
```
"encryptionContext": {
"aws:s3:arn": "arn:aws:s3:::amzn-s3-demo-bucket1/file_name"
}
```
當您搭配選用 S3 儲存貯體金鑰功能使用 SSE-KMS 時，加密內容值是儲存貯體的 ARN。
```
"encryptionContext": {
"aws:s3:arn": "arn:aws:s3:::amzn-s3-demo-bucket1"
}
```
## 傳送 AWS KMS 加密物件的請求
**重要**
AWS KMS 加密物件的所有 `GET`和 `PUT`請求必須使用 Secure Sockets Layer (SSL) 或 Transport Layer Security (TLS) 提出。請求也必須使用有效的登入資料簽署，例如 AWS Signature 第 4 版 （或 AWS Signature 第 2 版）。
AWS Signature 第 4 版是將 AWS 身分驗證資訊新增至 HTTP 傳送之請求的程序。為了安全起見，對 的大多數請求 AWS 都必須使用存取金鑰簽署，該金鑰包含存取金鑰 ID 和私密存取金鑰。這兩種金鑰通常稱為您的安全憑證。如需詳細資訊，請參閱身分[身分驗證請求 (AWS Signature 第 4 版)](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-authenticating-requests.html) 和 [Signature 第 4 版簽章程序](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html)。
**重要**
如果您的物件使用 SSE-KMS，請不要傳送 `GET` 請求與 `HEAD` 請求的加密請求標頭。否則，您會收到 HTTP 400 Bad Request (HTTP 400 錯誤的請求) 錯誤。
**Topics**
+ [
## AWS KMS keys
](#aws-managed-customer-managed-keys)
+ [
## Amazon S3 儲存貯體金鑰
](#sse-kms-bucket-keys)
+ [
## 要求伺服器端加密
](#require-sse-kms)
+ [
## 加密內容
](#encryption-context)
+ [
## 傳送 AWS KMS 加密物件的請求
](#aws-signature-version-4-sse-kms)
+ [
# 使用 AWS KMS (SSE-KMS) 指定伺服器端加密
](specifying-kms-encryption.md)
+ [
# 使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本
](bucket-key.md)
# 使用 AWS KMS (SSE-KMS) 指定伺服器端加密
根據預設，所有 Amazon S3 儲存貯體都設定了加密，所有上傳到 S3 儲存貯體的新物件都會在靜態時自動加密。伺服器端加密與 Amazon S3 受管金鑰 (SSE-S3) 是 Amazon S3 中每個儲存貯體的預設加密組態。若要使用不同類型的加密，您可以指定 S3 `PUT` 請求中要使用的伺服器端加密類型，也可以在目的地儲存貯體中更新預設加密組態。
如果您想要在`PUT`請求中指定不同的加密類型，您可以使用伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS)、雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)，或伺服器端加密搭配客戶提供的金鑰 (SSE-C)。若您想在目的地儲存貯體中設定不同的預設加密組態，您可以使用 SSE-KMS 或 DSSE-KMS。
如需變更一般用途儲存貯體之預設加密組態的詳細資訊，請參閱 [設定預設加密](default-bucket-encryption.md)。
當您將儲存貯體的預設加密組態變更為 SSE-KMS 時，並不會變更儲存貯體中現有 Amazon S3 物件的加密類型。若要在將預設加密組態更新為 SSE-KMS 之後變更既有物件的加密類型，您可以使用 Amazon S3 Batch Operations。您為 S3 Batch Operations 提供物件清單，而批次操作會呼叫個別 API 操作。您可以使用 [複製物件](batch-ops-copy-object.md) 動作來複製現有物件，該動作會將它們寫回與 SSE-KMS 加密物件相同的儲存貯體。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱 [使用 Batch Operations 大量執行物件操作](batch-ops.md) 和 *AWS 儲存部落格*文章[如何使用 S3 庫存清單、Amazon Athena 和 S3 Batch Operations 來追溯加密 Amazon S3 中的現有物件](https://aws.amazon.com/blogs/security/how-to-retroactively-encrypt-existing-objects-in-amazon-s3-using-s3-inventory-amazon-athena-and-s3-batch-operations/)。
您可以使用 Amazon S3 主控台、REST API 操作、SDK 和 () 來指定 SSE AWS SDKs AWS CLI。 AWS Command Line Interface 如需詳細資訊，請參閱下列主題。
**注意**
您可以在 Amazon S3 AWS KMS keys 中使用多區域。但是，Amazon S3 目前將多區域金鑰視為單區域金鑰，並且不使用金鑰的多區域功能。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[使用多區域金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)。
**注意**
如果您想要使用其他帳戶擁有的 KMS 金鑰，您必須具有該金鑰的許可。如需詳細了解 KMS 金鑰跨帳戶權限，請參閱《AWS Key Management Service 開發人員指南》**中的[建立其他帳戶可使用的 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)。
## 使用 S3 主控台
本主題說明如何設定或變更物件的加密類型，以使用 Amazon S3 主控台搭配 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 使用伺服器端加密。
**注意**
如果您的物件小於 5 GB，您可以變更物件的加密。如果您的物件大於 5 GB，您必須使用 [AWS CLI](mpu-upload-object.md#UsingCLImpUpload) 或 [AWS SDK](CopyingObjectsMPUapi.md) 來變更物件的加密。
如需變更物件加密所需的其他許可清單，請參閱[Amazon S3 API 操作所需的許可](using-with-s3-policy-actions.md)。如需授予此許可的範例政策，請參閱[Amazon S3 的身分型政策範例](example-policies-s3.md)。
如果您變更物件的加密，則會建立新物件來取代舊物件。如果啟用 S3 版本控制，則系統會建立物件的新版本，且現有物件會變成較舊的版本。變更屬性的角色也會成為新物件 (或物件版本) 的擁有者。
**新增或變更物件的加密**
1. 登入 AWS 管理主控台 並開啟位於 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在導覽窗格中，選擇**儲存貯體**，然後選擇**一般用途儲存貯體**索引標籤。導覽至包含您要變更之物件的 Amazon S3 儲存貯體或資料夾。
1. 選取您要變更之物件的核取方塊。
1. 從**動作**功能表上顯示的選項清單中，選擇**編輯伺服器端加密**。
1. 捲動至**伺服器端加密**區段。
1. 在**加密設定**底下，選擇**使用預設加密的儲存貯體設定**或**覆寫預設加密的儲存貯體設定**。
**重要**
如果您針對預設加密組態使用 SSE-KMS 選項，則受到 AWS KMS的每秒請求數目 (RPS) 配額限制。如需 AWS KMS 配額以及如何請求提高配額的詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[配額](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html)。
1. 若您選擇**覆寫預設加密的儲存貯體設定**，請設定下列加密設定。
1. 在**加密類型**下，選擇**伺服器端加密與 AWS Key Management Service 金鑰 (SSE-KMS)**。
1. 在 **AWS KMS 金鑰**之下，執行下列其中一個動作，以選擇 KMS 金鑰：
+ 若要從可用的 KMS 金鑰清單中選擇，請選擇**從 AWS KMS keys中選擇**，然後從可用金鑰清單中選擇您的 **KMS 金鑰**。
AWS 受管金鑰 (`aws/s3`) 和您的客戶受管金鑰都會顯示在此清單中。如需詳細了解客戶受管金鑰，請參閱《AWS Key Management Service 開發人員指南》**中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
+ 若要輸入 KMS 金鑰 ARN，請選擇**輸入 AWS KMS key ARN**，然後在出現的欄位中輸入您的 KMS 金鑰 ARN。
+ 若要在 AWS KMS 主控台中建立新的客戶受管金鑰，請選擇**建立 KMS 金鑰**。
如需建立 的詳細資訊 AWS KMS key，請參閱《 *AWS Key Management Service 開發人員指南*》中的[建立金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)。
**重要**
您只能使用 AWS 區域 與儲存貯體相同的 KMS 金鑰。Amazon S3 主控台僅會列出與儲存貯體位於相同區域的前 100 個 KMS 金鑰。若要使用未列出的 KMS 金鑰，必須輸入 KMS 金鑰 ARN。若您想要使用其他帳戶的 KMS 金鑰，您必須先具有該金鑰的使用權限，然後輸入 KMS 金鑰 ARN。
Amazon S3 僅支援對稱加密 KMS 金鑰，而不支援非對稱 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[識別對稱和非對稱 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html)。
1. 在**其他複製設定**下，選擇**複製來源設定**、**不要指定設定**或**指定設定**。**複製來源設定**是預設選項。如果您只想複製物件但不想包含來源設定屬性，請選擇**不要指定設定**。選擇**指定設定**以指定儲存類別、ACL、物件標籤、中繼資料、伺服器端加密和額外檢查總和的設定。
1. 選擇 **Save changes** (儲存變更)。
**注意**
此動作會將加密套用至所有指定的物件。加密資料夾時，請等待儲存作業完成，然後再將新物件新增至資料夾。
## 使用 REST API
建立物件 (即上傳新物件或複製現有物件) 時，可以指定使用伺服器端加密和 AWS KMS keys (SSE-KMS) 來加密資料。若要執行這項操作，請將 `x-amz-server-side-encryption` 標頭新增至要求。將標頭的值設為加密演算法 `aws:kms`。Amazon S3 會傳回回應標頭 `x-amz-server-side-encryption`，確認已使用 SSE-KMS 存放物件。
如果您使用 `aws:kms` 的值指定 `x-amz-server-side-encryption` 標頭，也可以使用下列要求標頭：
+ `x-amz-server-side-encryption-aws-kms-key-id`
+ `x-amz-server-side-encryption-context`
+ `x-amz-server-side-encryption-bucket-key-enabled`
**Topics**
+ [
### 支援 SSE-KMS 的 Amazon S3 REST API 操作
](#sse-request-headers-kms)
+ [
### 加密內容 (`x-amz-server-side-encryption-context`)
](#s3-kms-encryption-context)
+ [
### AWS KMS 金鑰 ID (`x-amz-server-side-encryption-aws-kms-key-id`)
](#s3-kms-key-id-api)
+ [
### S3 儲存貯體金鑰 (`x-amz-server-side-encryption-aws-bucket-key-enabled`)
](#bucket-key-api)
### 支援 SSE-KMS 的 Amazon S3 REST API 操作
下列 REST API 操作接受 `x-amz-server-side-encryption`、`x-amz-server-side-encryption-aws-kms-key-id` 和 `x-amz-server-side-encryption-context` 請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) – 使用 `PUT` API 操作上傳資料時，您可以指定這些請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) – 複製物件時，您會同時有來源物件與目標物件。當您使用 `CopyObject` 操作傳遞 SSE-KMS 標頭時，這些標頭只會套用至目標物件。複製現有物件時，除非明確請求伺服器端加密，否則無論來源物件是否經過加密，都不會加密目的地物件。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) – 使用 `POST` 操作上傳物件時，您會提供與表單欄位中相同的資訊，而不是請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) – 使用分段上傳 API 操作上傳大型物件時，您可以指定這些標頭。您可以在 `CreateMultipartUpload` 請求中指定這些標頭。
使用伺服器端加密存放物件時，下列 REST API 操作的回應標頭會傳回 `x-amz-server-side-encryption` 標頭。
+ [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_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.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_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.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)
+ [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/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)
**重要**
如果您未使用 Secure Sockets Layer (SSL)、Transport Layer Security (TLS) 或第 4 版簽署程序，則受 AWS KMS 保護物件的所有 `GET` 和 `PUT` 請求將會失敗。
如果您的物件使用 SSE-KMS，請勿傳送 `GET` 請求與 `HEAD` 請求的加密請求標頭，否則您會收到 HTTP 400 BadRequest 錯誤。
### 加密內容 (`x-amz-server-side-encryption-context`)
如果您指定 `x-amz-server-side-encryption:aws:kms`，則 Amazon S3 API 支援具有 `x-amz-server-side-encryption-context` 標頭的加密內容。加密內容是一組金鑰值對，其中包含資料的其他相關內容資訊。
Amazon S3 會自動使用物件或儲存貯體 Amazon Resource Name (ARN) 作為加密內容對。如果您在未啟用 S3 儲存貯體金鑰的情況下使用 SSE-KMS，則您使用物件 ARN 做為加密內容，例如 `arn:aws:s3:::object_ARN`。不過，如果您使用 SSE-KMS 並啟用 S3 儲存貯體金鑰，則會將儲存貯體 ARN 用於加密內容，例如 `arn:aws:s3:::bucket_ARN`。
您可以使用 `x-amz-server-side-encryption-context` 標頭來提供其他加密內容對。不過，由於加密內容未加密，因此請確保其中不包含敏感資訊。Amazon S3 會一起存放此附加金鑰對與預設加密內容。
如需 Amazon S3 中加密內容的相關資訊，請參閱 [加密內容](UsingKMSEncryption.md#encryption-context)。如需有關加密內容的更多資訊，請參閱《AWS Key Management Service 開發人員指南》**中的 [AWS Key Management Service 概念：加密內容](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)。
### AWS KMS 金鑰 ID (`x-amz-server-side-encryption-aws-kms-key-id`)
您可以使用 `x-amz-server-side-encryption-aws-kms-key-id` 標頭來指定用來保護資料之客戶受管金鑰的 ID。如果您指定 `x-amz-server-side-encryption:aws:kms` 標頭，但未提供 `x-amz-server-side-encryption-aws-kms-key-id` 標頭，則 Amazon S3 會使用 AWS 受管金鑰 (`aws/s3`) 來保護資料。如果您想要使用客戶受管的金鑰，則必須提供客戶受管金鑰的 `x-amz-server-side-encryption-aws-kms-key-id` 標頭。
**重要**
當您在 Amazon S3 中使用 AWS KMS key 進行伺服器端加密時，您必須選擇對稱加密 KMS 金鑰。Amazon S3 只支援對稱加密 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
### S3 儲存貯體金鑰 (`x-amz-server-side-encryption-aws-bucket-key-enabled`)
您可以使用 `x-amz-server-side-encryption-aws-bucket-key-enabled` 請求標頭在物件層級啟用或停用 S3 儲存貯體金鑰。S3 儲存貯體金鑰透過減少來自 AWS KMS Amazon S3 的請求流量來降低請求成本 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
如果您指定 `x-amz-server-side-encryption:aws:kms` 標頭但未提供 `x-amz-server-side-encryption-aws-bucket-key-enabled` 標頭，則您的物件使用目的地儲存貯體存儲桶的 S3 儲存貯體金鑰設定來加密您的物件。如需詳細資訊，請參閱[在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)。
## 使用 AWS CLI
若要使用下列範例 AWS CLI 命令，請將 取代`user input placeholders`為您自己的資訊。
當您上傳新物件或複製現有物件時，您可以指定使用伺服器端加密搭配 AWS KMS 金鑰來加密資料。若要執行這項操作，請將 `--server-side-encryption aws:kms` 標頭新增至要求。使用 `--ssekms-key-id example-key-id` 新增您建立[的客戶受管 AWS KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#customer-cmk)。如果您指定 `--server-side-encryption aws:kms`，但未提供 AWS KMS 金鑰 ID，Amazon S3 將使用 AWS 受管金鑰。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms --ssekms-key-id example-key-id --body filepath
```
您還可以透過新增 `--bucket-key-enabled` 或 `--no-bucket-key-enabled`，在 PUT 或 COPY 操作上啟用或停用 Amazon S3 儲存貯體金鑰。Amazon S3 儲存貯體金鑰可以透過減少來自 Amazon S3 的 AWS KMS 請求流量來降低請求成本 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 成本](https://docs.aws.amazon.com//AmazonS3/latest/userguide/bucket-key.html)。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms --bucket-key-enabled --body filepath
```
您可以將未加密的物件加密以使用 SSE-KMS，方法是將物件複製回原位。
```
aws s3api copy-object --bucket amzn-s3-demo-bucket --key example-object-key --body filepath --bucket amzn-s3-demo-bucket --key example-object-key --sse aws:kms --sse-kms-key-id example-key-id --body filepath
```
## 使用 AWS SDKs
使用 AWS SDKs時，您可以請求 Amazon S3 使用 AWS KMS keys 進行伺服器端加密。下列範例示範如何使用 SSE-KMS 搭配適用於 Java 和 .NET AWS SDKs。如需其他 SDKs的資訊，請參閱《 AWS 開發人員中心》上的[範例程式碼和程式庫](https://aws.amazon.com/code)。
**重要**
當您在 Amazon S3 中使用 AWS KMS key 進行伺服器端加密時，您必須選擇對稱加密 KMS 金鑰。Amazon S3 只支援對稱加密 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
### `CopyObject` 操作
複製物件時，請新增相同的請求屬性 (`ServerSideEncryptionMethod` 與 `ServerSideEncryptionKeyManagementServiceKeyId`)，以請求 Amazon S3 使用 AWS KMS key。如需複製物件的詳細資訊，請參閱「[複製、移動和重新命名物件](copy-object.md)」。
### `PUT` 操作
------
#### [ Java ]
使用 上傳物件時 適用於 Java 的 AWS SDK，您可以透過 AWS KMS key 新增 `SSEAwsKeyManagementParams` 屬性來請求 Amazon S3 使用 ，如下列請求所示：
```
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName, file).withSSEAwsKeyManagementParams(new SSEAwsKeyManagementParams());
```
在此情況下，Amazon S3 會使用 AWS 受管金鑰 (`aws/s3`)。如需詳細資訊，請參閱[搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。您可以選擇建立對稱加密 KMS 金鑰，並在請求中指定該金鑰，如下列範例所示：
```
PutObjectRequest putRequest = new PutObjectRequest(bucketName,
keyName, file).withSSEAwsKeyManagementParams(new SSEAwsKeyManagementParams(keyID));
```
如需建立客戶受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[程式設計 AWS KMS API](https://docs.aws.amazon.com/kms/latest/developerguide/programming-top.html)。
如需上傳物件的可行程式碼範例，請參閱下列主題。若要使用這些範例，您必須更新這些程式碼範例並提供加密資訊，如上述程式碼片段所示。
+ 如需以單一操作上傳物件，請參閱 [上傳物件](upload-objects.md)。
+ 如需使用高階或低階分段上傳 API 操作的分段上傳，請參閱[使用分段上傳來上傳物件](mpu-upload-object.md)。
------
#### [ .NET ]
使用 上傳物件時 適用於 .NET 的 AWS SDK，您可以透過 AWS KMS key 新增 `ServerSideEncryptionMethod` 屬性來請求 Amazon S3 使用 ，如下列請求所示：
```
PutObjectRequest putRequest = new PutObjectRequest
{
BucketName = amzn-s3-demo-bucket,
Key = keyName,
// other properties
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS
};
```
在此情況下，Amazon S3 會使用 AWS 受管金鑰。如需詳細資訊，請參閱[搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。您可以選擇建立自己的對稱加密客戶自管金鑰，並在請求中指定該金鑰，如下列範例所示：
```
PutObjectRequest putRequest1 = new PutObjectRequest
{
BucketName = amzn-s3-demo-bucket,
Key = keyName,
// other properties
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
ServerSideEncryptionKeyManagementServiceKeyId = keyId
};
```
如需建立客戶受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[程式設計 AWS KMS API](https://docs.aws.amazon.com/kms/latest/developerguide/programming-top.html)。
如需上傳物件的可行程式碼範例，請參閱下列主題。若要使用這些範例，您必須更新這些程式碼範例並提供加密資訊，如上述程式碼片段所示。
+ 如需以單一操作上傳物件，請參閱 [上傳物件](upload-objects.md)。
+ 如需使用高階或低階分段上傳 API 操作的分段上傳，請參閱[使用分段上傳來上傳物件](mpu-upload-object.md)。
------
### 預先簽章的 URL
------
#### [ Java ]
為使用 AWS KMS key加密的物件建立預先簽章 URL 時，您必須明確指定第 4 版簽署程序，如下列範例所示：
```
ClientConfiguration clientConfiguration = new ClientConfiguration();
clientConfiguration.setSignerOverride("AWSS3V4SignerType");
AmazonS3Client s3client = new AmazonS3Client(
new ProfileCredentialsProvider(), clientConfiguration);
...
```
如需程式碼範例，請參閱「[使用預先簽章的 URL 來共用物件](ShareObjectPreSignedURL.md)」。
------
#### [ .NET ]
為使用 AWS KMS key加密的物件建立預先簽章 URL 時，您必須明確指定第 4 版簽署程序，如下列範例所示：
```
AWSConfigs.S3Config.UseSignatureVersion4 = true;
```
如需程式碼範例，請參閱「[使用預先簽章的 URL 來共用物件](ShareObjectPreSignedURL.md)」。
------
# 使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本
Amazon S3 儲存貯體金鑰使用 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 降低 Amazon S3 伺服器端加密的成本。使用 SSE-KMS 的儲存貯體層級金鑰，可將 Amazon S3 的 AWS KMS 請求流量降低高達 99% 的請求成本 AWS KMS。只要在 AWS 管理主控台中點擊幾下，而無需對用戶端應用程式進行任何變更，您就可以設定儲存貯體，在新物件上使用 S3 儲存貯體金鑰進行 SSE-KMS 加密。
**注意**
使用 AWS Key Management Service (AWS KMS) 金鑰 (DSSE-KMS) 的雙層伺服器端加密不支援 S3 儲存貯體金鑰。
## 適用於 SSE-KMS 的 S3 儲存貯體金鑰
存取以 SSE-KMS 加密的數百萬或數十億個物件的工作負載可以產生大量的請求 AWS KMS。當您使用 SSE-KMS 來保護沒有 S3 儲存貯體金鑰的資料時，Amazon S3 會為每個物件使用個別 AWS KMS [資料金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys)。在此情況下，Amazon S3 AWS KMS 每次對 KMS 加密物件提出請求時都會呼叫 。如需 SSE-KMS 如何運作的相關資訊，請參閱 [搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。
當您將儲存貯體設定為使用 SSE-KMS 的 S3 儲存貯體金鑰時， 會從中 AWS 產生短期儲存貯體層級金鑰 AWS KMS，然後暫時將其保留在 S3 中。此儲存貯體層級金鑰會其生命週期中建立資料金鑰。S3 儲存貯體金鑰在 Amazon S3 內的有限期間內使用，減少 S3 向 提出請求 AWS KMS 以完成加密操作的需求。這可減少從 S3 到 的流量 AWS KMS，可讓您以先前成本的一小部分存取 Amazon S3 中的 AWS KMS加密物件。
每個請求者至少擷取一次唯一的儲存貯體層級金鑰，以確保在 an AWS KMS CloudTrail 事件中擷取請求者的金鑰存取權。當呼叫者使用不同的角色或帳戶，或具有不同範圍政策的相同角色時，Amazon S3 會將呼叫者視為不同的請求者。 AWS KMS 請求節省會反映請求者的數量、請求模式，以及請求物件的相對存留期。例如，較少的請求者數量、在有限的時間範圍內請求多個物件，以及使用相同的儲存貯體層級金鑰加密，會節省更多成本。
**注意**
使用 S3 儲存貯體金鑰可讓您透過使用儲存貯體層級金鑰，減少 AWS KMS 對 `Encrypt`、 和 `Decrypt`操作的請求`GenerateDataKey`，以節省 AWS KMS 請求成本。根據設計，利用此儲存貯體層級金鑰的後續請求不會導致 AWS KMS API 請求或根據 AWS KMS 金鑰政策驗證存取權。
當您設定 S3 儲存貯體金鑰時，儲存貯體中已存在的物件不會使用 S3 儲存貯體金鑰。若要為現有物件設定 S3 儲存貯體金鑰，您可以使用 `CopyObject` 操作。如需詳細資訊，請參閱[在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)。
Amazon S3 只會針對相同 AWS KMS key加密的物件共用 S3 儲存貯體金鑰。S3 儲存貯體金鑰與由 建立的 KMS 金鑰 AWS KMS、[匯入的金鑰材料](https://docs.aws.amazon.com/kms/latest/developerguide/importing-keys.html)，以及[由自訂金鑰存放區支援的金鑰材料](https://docs.aws.amazon.com/kms/latest/developerguide/custom-key-store-overview.html)相容。
![\[圖表顯示 AWS KMS 產生儲存貯體金鑰，為儲存貯體中的物件建立資料金鑰。\]](http://docs.aws.amazon.com/zh_tw/AmazonS3/latest/userguide/images/S3-Bucket-Keys.png)
## 設定 S3 儲存貯體金鑰
您可以透過 Amazon S3 主控台 AWS CLI、 AWS SDKs 或 REST API，將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰。 Amazon S3 在儲存貯體上啟用 S3 儲存貯體金鑰後，使用不同所指定 SSE-KMS 金鑰上傳的物件將使用自己的 S3 儲存貯體金鑰。無論您的 S3 儲存貯體金鑰設定為何，您都可以在請求中包含具有 `true` 或 `false` 值的 `x-amz-server-side-encryption-bucket-key-enabled` 標頭，以覆寫儲存貯體設定。
在您將儲存貯體設定為使用 S3 儲存貯體金鑰之前，請先檢閱 [啟用 S3 儲存貯體金鑰之前，要注意的變更](#bucket-key-changes)。
### 使用 Amazon S3 主控台設定 S3 儲存貯體金鑰
當您建立新儲存貯體時，您可以將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰。您也可以透過更新儲存貯體屬性，將現有儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰。
如需詳細資訊，請參閱[設定您的儲存貯體以使用具有 SSE-KMS 的 S3 儲存貯體來獲取新物件](configuring-bucket-key.md)。
### REST API AWS CLI和軟體 AWS 開發套件支援 S3 儲存貯體金鑰
您可以使用 REST API AWS CLI或 AWS SDK，將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰。您也可以在物件層級啟用 S3 儲存貯體金鑰。
如需詳細資訊，請參閱下列內容：
+ [在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)
+ [設定您的儲存貯體以使用具有 SSE-KMS 的 S3 儲存貯體來獲取新物件](configuring-bucket-key.md)
下列 API 操作支援 SSE-KMS 的 S3 儲存貯體金鑰：
+ [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)
+ `ServerSideEncryptionRule`接受啟用和停用 S3 儲存貯體金鑰的 `BucketKeyEnabled` 參數。
+ [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)
+ `ServerSideEncryptionRule` 會傳回 `BucketKeyEnabled` 的設定。
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)、[CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)、[CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) 和 [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ `x-amz-server-side-encryption-bucket-key-enabled` 請求標頭啟用或停用在物件層級的 S3 儲存貯體金鑰。
+ [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)、[GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)、[UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)、[UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html) 和 [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ `x-amz-server-side-encryption-bucket-key-enabled` 回應標頭表示是否為物件啟用或停用 S3 儲存貯體金鑰。
### 使用 CloudFormation
在 中 CloudFormation， `AWS::S3::Bucket` 資源包含名為 的加密屬性`BucketKeyEnabled` ，可用來啟用或停用 S3 儲存貯體金鑰。
如需詳細資訊，請參閱[使用 CloudFormation](configuring-bucket-key.md#enable-bucket-key-cloudformation)。
## 啟用 S3 儲存貯體金鑰之前，要注意的變更
啟用 S3 儲存貯體金鑰之前，請注意下列相關變更：
### IAM 或 AWS KMS 金鑰政策
如果您現有的 AWS Identity and Access Management (IAM) 政策或 AWS KMS 金鑰政策使用物件 Amazon Resource Name (ARN) 做為加密內容，以精簡或限制對 KMS 金鑰的存取，這些政策將無法與 S3 儲存貯體金鑰搭配使用。S3 儲存貯體金鑰使用儲存貯體 ARN 作為加密內容。啟用 S3 儲存貯體金鑰之前，請更新您的 IAM 政策或 AWS KMS 金鑰政策，以使用儲存貯體 ARN 做為加密內容。
如需加密內容與 S3 儲存貯體金鑰的詳細資訊，請參閱 [加密內容](UsingKMSEncryption.md#encryption-context)。
### 的 CloudTrail 事件 AWS KMS
啟用 S3 儲存貯體金鑰後， AWS KMS CloudTrail 事件會記錄儲存貯體 ARN，而不是物件 ARN。此外，您會在日誌中看到較少的 SSE-KMS 物件 KMS CloudTrail 事件。 由於 Amazon S3 中的金鑰材料有時間限制，因此對 提出的請求較少 AWS KMS。
## 使用 S3 儲存貯體金鑰與複寫
您可以將 S3 儲存貯體金鑰與相同區域複寫 (SRR) 和跨區域複寫 (CRR) 搭配使用。
Amazon S3 複寫加密物件時，通常會在目的地儲存貯體中保留複本物件的加密設定。不過，如果來源物件未加密，且目的地儲存貯體使用預設加密或 S3 儲存貯體金鑰，Amazon S3 會使用目的地儲存貯體的組態加密物件。
下列範例說明 S3 儲存貯體金鑰如何與複寫搭配使用。如需詳細資訊，請參閱[複寫加密的物件 (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)。
**Example 範例 1 — 來源物件使用 S3 儲存貯體金鑰，目的地儲存貯體使用預設加密**
如果您的來源物件使用 S3 儲存貯體金鑰，但目的地儲存貯體使用預設加密搭配 SSE-KMS，則複本物件會在目的地儲存貯體中維護其 S3 儲存貯體金鑰加密設定。目的地儲存貯體仍使用預設加密搭配 SSE-KMS。
**Example 範例 2 — 來源物件未加密，目的地儲存貯體使用 S3 儲存貯體金鑰搭配 SSE-KMS**
如果您的來源物件未加密，且目的地儲存貯體使用 SSE-KMS 的 S3 儲存貯體金鑰，則複本物件會使用目的地儲存貯體中的 SSE-KMS，使用 S3 儲存貯體金鑰加密。這會導致來源物件的 `ETag` 與複本物件的 `ETag` 不同。您必須更新可使用 `ETag` 的應用程式來容納這項差異。
## 使用 S3 儲存貯體金鑰
如需啟用及使用 S3 儲存貯體金鑰的詳細資訊，請參閱下列章節：
+ [設定您的儲存貯體以使用具有 SSE-KMS 的 S3 儲存貯體來獲取新物件](configuring-bucket-key.md)
+ [在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)
+ [檢視 S3 儲存貯體金鑰的設定](viewing-bucket-key-settings.md)
# 設定您的儲存貯體以使用具有 SSE-KMS 的 S3 儲存貯體來獲取新物件
當您使用 AWS Key Management Service (AWS KMS) 金鑰 (SSE-KMS) 設定伺服器端加密時，您可以將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰。S3 儲存貯體金鑰可減少從 Amazon S3 到 的請求流量， AWS KMS 並降低 SSE-KMS 的成本。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
您可以使用 Amazon S3 主控台、REST API、 AWS SDKs、 AWS Command Line Interface (AWS CLI) 或 ，將儲存貯體設定為在新物件上使用 SSE-KMS 的 S3 儲存貯體金鑰 CloudFormation。 Amazon S3 如果您想要啟用或停用現有物件的 S3 儲存貯體金鑰，可以使用 `CopyObject` 操作。如需詳細資訊，請參閱 [在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md) 與 [使用 Batch Operations 為 SSE-KMS 啟用 S3 儲存貯體金鑰](batch-ops-copy-example-bucket-key.md)。
針對來源或目的地儲存貯體啟用 S3 儲存貯體金鑰時，加密內容將是儲存貯體 Amazon Resource Name (ARN)，而不是物件 ARN，例如 `arn:aws:s3:::bucket_ARN`。您需要更新 IAM 政策，才能將儲存貯體 ARN 用於加密內容。如需詳細資訊，請參閱[S3 儲存貯體金鑰和複寫](replication-config-for-kms-objects.md#bk-replication)。
下列範例說明 S3 儲存貯體金鑰如何與複寫搭配使用。如需詳細資訊，請參閱[複寫加密的物件 (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)。
**先決條件**
在您將儲存貯體設定為使用 S3 儲存貯體金鑰之前，請先檢閱 [啟用 S3 儲存貯體金鑰之前，要注意的變更](bucket-key.md#bucket-key-changes)。
**Topics**
## 使用 S3 主控台
在 S3 主控台中，您可以啟用或停用新的或現有儲存貯體的 S3 儲存貯體金鑰。S3 主控台中的物件會從儲存貯體組態繼承其 S3 儲存貯體金鑰設定。當您為儲存貯體啟用 S3 儲存貯體金鑰時，上傳至儲存貯體的新物件使用 S3 儲存貯體金鑰以進行 SSE-KMS。
**在啟用 S3 儲存貯體金鑰的儲存貯體中上傳、複製或修改物件**
如果您在已啟用 S3 儲存貯體金鑰的儲存貯體中上傳、修改或複製物件，則該物件的 S3 儲存貯體金鑰設定可能會更新以符合儲存貯體組態。
如果物件已啟用 S3 儲存貯體金鑰，則在您複製或修改物件時，該物件的 S3 儲存貯體金鑰設定不會變更。但是，如果您修改或複製未啟用 S3 儲存貯體金鑰的物件，且目的地儲存貯體具有 S3 儲存貯體金鑰組態，則物件會繼承目的地儲存貯體的 S3 儲存貯體金鑰設定。例如，如果您的來源物件沒有啟用 S3 儲存貯體金鑰，但目的地儲存貯體已啟用 S3 儲存貯體金鑰，則將為該物件啟用 S3 儲存貯體金鑰。
**在建立新儲存貯體時啟用 S3 儲存貯體金鑰**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 選擇**建立儲存貯體**。
1. 輸入您的儲存貯體名稱，然後選擇您的 AWS 區域。
1. 在**預設加密**之下，針對**加密金鑰類型**選擇 **AWS Key Management Service 金鑰 (SSE-KMS)**。
1. 在 **AWS KMS 金鑰**之下，執行下列其中一個動作，以選擇 KMS 金鑰：
+ 若要從可用的 KMS 金鑰清單中選擇，請選擇**從中選擇 AWS KMS keys**，然後從可用的金鑰清單中選擇您的 **KMS** 金鑰。
AWS 受管金鑰 (`aws/s3`) 和您的客戶受管金鑰都會顯示在此清單中。如需客戶受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
+ 若要輸入 KMS 金鑰 ARN，請選擇**輸入 AWS KMS key ARN**，然後在出現的欄位中輸入您的 KMS 金鑰 ARN。
+ 若要在 AWS KMS 主控台中建立新的客戶受管金鑰，請選擇**建立 KMS 金鑰**。
如需建立 的詳細資訊 AWS KMS key，請參閱《 *AWS Key Management Service 開發人員指南*》中的[建立金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)。
1. 在 **Bucket Key** (儲存貯體金鑰) 底下，選擇 **Enable** (啟用)。
1. 選擇 **Create bucket** (建立儲存貯體)。
Amazon S3 會在啟用 S3 儲存貯體金鑰的情況下建立您的儲存貯體。您上傳到儲存貯體的新物件將使用 S3 儲存貯體金鑰。
若要停用 S3 儲存貯體金鑰，請依照上述步驟執行，然後選擇 **Disable (停用)**。
**為現有儲存貯體啟用 S3 儲存貯體金鑰**
1. 開啟位於 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 的 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您要啟用 S3 儲存貯體金鑰的儲存貯體。
1. 選擇**屬性**索引標籤。
1. 在 **Default encryption (預設加密)** 底下，選擇 **Edit (編輯)**。
1. 在**預設加密**之下，針對**加密金鑰類型**選擇 **AWS Key Management Service 金鑰 (SSE-KMS)**。
1. 在 **AWS KMS 金鑰**之下，執行下列其中一個動作，以選擇 KMS 金鑰：
+ 若要從可用的 KMS 金鑰清單中選擇，請選擇**從中選擇 AWS KMS keys**，然後從可用的金鑰清單中選擇您的 **KMS** 金鑰。
AWS 受管金鑰 (`aws/s3`) 和您的客戶受管金鑰都會顯示在此清單中。如需客戶受管金鑰的詳細資訊，請參閱《 *AWS Key Management Service 開發人員指南*》中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
+ 若要輸入 KMS 金鑰 ARN，請選擇**輸入 AWS KMS key ARN**，然後在出現的欄位中輸入您的 KMS 金鑰 ARN。
+ 若要在 AWS KMS 主控台中建立新的客戶受管金鑰，請選擇**建立 KMS 金鑰**。
如需建立 的詳細資訊 AWS KMS key，請參閱《 *AWS Key Management Service 開發人員指南*》中的[建立金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)。
1. 在 **Bucket Key** (儲存貯體金鑰) 底下，選擇 **Enable** (啟用)。
1. 選擇 **Save changes** (儲存變更)。
Amazon S3 為新增至儲存貯體的新物件啟用 S3 儲存貯體金鑰。現有物件不使用 S3 儲存貯體金鑰。若要為現有物件設定 S3 儲存貯體金鑰，您可以使用 `CopyObject` 操作。如需詳細資訊，請參閱[在物件層級設定 S3 儲存貯體金鑰](configuring-bucket-key-object.md)。
若要停用 S3 儲存貯體金鑰，請依照上述步驟執行，然後選擇 **Disable (停用)**。
## 使用 REST API
您可以使用 [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) 來為您的儲存貯體啟用或停用 S3 儲存貯體金鑰。若要使用 `PutBucketEncryption` 設定 S3 儲存貯體金鑰，請使用 [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html) 資料類型，其中包含具有 SSE-KMS 的預設加密。您也可以指定客戶受管金鑰的 KMS 金鑰 ID，選擇性地使用客戶受管金鑰。
如需詳細資訊和語法範例，請參閱 [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)。
## 使用適用於 Java 的 AWS 開發套件
下列範例使用 適用於 Java 的 AWS SDK，以 SSE-KMS 和 S3 儲存貯體金鑰啟用預設儲存貯體加密。
------
#### [ Java ]
```
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.DEFAULT_REGION)
.build();
ServerSideEncryptionByDefault serverSideEncryptionByDefault = new ServerSideEncryptionByDefault()
.withSSEAlgorithm(SSEAlgorithm.KMS);
ServerSideEncryptionRule rule = new ServerSideEncryptionRule()
.withApplyServerSideEncryptionByDefault(serverSideEncryptionByDefault)
.withBucketKeyEnabled(true);
ServerSideEncryptionConfiguration serverSideEncryptionConfiguration =
new ServerSideEncryptionConfiguration().withRules(Collections.singleton(rule));
SetBucketEncryptionRequest setBucketEncryptionRequest = new SetBucketEncryptionRequest()
.withServerSideEncryptionConfiguration(serverSideEncryptionConfiguration)
.withBucketName(bucketName);
s3client.setBucketEncryption(setBucketEncryptionRequest);
```
------
## 使用 AWS CLI
下列範例使用 AWS CLI，以 SSE-KMS 和 S3 儲存貯體金鑰啟用預設儲存貯體加密。以您自己的資訊取代 `user input placeholders`。
```
aws s3api put-bucket-encryption --bucket amzn-s3-demo-bucket --server-side-encryption-configuration '{
"Rules": [
{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "aws:kms",
"KMSMasterKeyID": "KMS-Key-ARN"
},
"BucketKeyEnabled": true
}
]
}'
```
## 使用 CloudFormation
如需使用 設定 S3 儲存貯體金鑰的詳細資訊 CloudFormation，請參閱*AWS CloudFormation 《 使用者指南*》中的 [AWS::S3::Bucket ServerSideEncryptionRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket-serversideencryptionrule.html)。
# 在物件層級設定 S3 儲存貯體金鑰
當您使用 REST API、 AWS SDKs 或 執行 PUT 或 COPY 操作時 AWS CLI，您可以透過新增具有 `true`或 `false`值的`x-amz-server-side-encryption-bucket-key-enabled`請求標頭，在物件層級啟用或停用 S3 儲存貯體金鑰。S3 儲存貯體金鑰透過減少從 Amazon S3 到 的請求流量，減少使用 AWS Key Management Service (AWS KMS) (SSE-KMS) 的伺服器端加密成本 AWS KMS。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
當您使用 PUT 或 COPY 操作為物件設定 S3 儲存貯體金鑰時，Amazon S3 只會更新該物件的設定。目的地儲存貯體的 S3 儲存貯體金鑰設定不會變更。如果您將 KMS 加密物件的 PUT 或 COPY 請求提交至啟用 S3 儲存貯體金鑰的儲存貯體，除非您停用請求標頭中的金鑰，否則物件層級操作將自動使用 S3 儲存貯體金鑰。如果您沒有為物件指定 S3 儲存貯體金鑰，Amazon S3 會將目的地儲存貯體的 S3 儲存貯體金鑰設定套用至物件。
**必要條件：**
將物件設定為使用 S3 儲存貯體金鑰之前，請先檢閱 [啟用 S3 儲存貯體金鑰之前，要注意的變更](bucket-key.md#bucket-key-changes)。
**Topics**
+ [
## Amazon S3 批次操作
](#bucket-key-object-bops)
+ [
## 使用 REST API
](#bucket-key-object-rest)
+ [
## 使用適用於 Java 的 AWS SDK (PutObject)
](#bucket-key-object-sdk)
+ [
## 使用 AWS CLI (PutObject)
](#bucket-key-object-cli)
## Amazon S3 批次操作
若要加密現有的 Amazon S3 物件，您可以使用 Amazon S3 批次操作。請提供 S3 批次操作可操作的物件清單，批次操作就會呼叫個別 API 來執行指定的操作。
您可以使用 [S3 批次操作複製操作](https://docs.aws.amazon.com/AmazonS3/latest/userguide/batch-ops-copy-object.html)來複製現有的未加密物件，並在相同的儲存貯體中寫入新的加密物件。單一批次操作任務可在數十億個物件上執行指定的操作。如需詳細資訊，請參閱「[使用 Batch Operations 大量執行物件操作](batch-ops.md)」和[使用 Amazon S3 批次操作來加密物件](https://aws.amazon.com/blogs/storage/encrypting-objects-with-amazon-s3-batch-operations/)。
## 使用 REST API
當您使用 SSE-KMS 時，可以使用下列 API 操作為物件啟用 S3 儲存貯體金鑰：
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) — 當您上傳物件時，您可以指定 `x-amz-server-side-encryption-bucket-key-enabled` 請求標頭，以在物件層級啟用或停用 S3 儲存貯體金鑰。
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) — 當您複製物件並設定 SSE-KMS 時，您可以指定 `x-amz-server-side-encryption-bucket-key-enabled` 請求標頭，以啟用或停用物件的 S3 儲存貯體金鑰。
+ [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) — 當您使用 `POST` 操作上傳物件並設定 SSE-KMS 時，您可以使用 `x-amz-server-side-encryption-bucket-key-enabled` 表單欄位來啟用或停用物件的 S3 儲存貯體金鑰。
+ [CreateMutlipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) — 當您使用 `CreateMultipartUpload` API 操作上傳大型物件並設定 SSE-KMS 時，您可以使用 `x-amz-server-side-encryption-bucket-key-enabled` 請求標頭來啟用或停用物件的 S3 儲存貯體金鑰。
若要在物件層級啟用 S3 儲存貯體金鑰，請包含 `x-amz-server-side-encryption-bucket-key-enabled` 請求標頭。如需有關 SSE-KMS 和 REST API 的詳細資訊，請參閱 [使用 REST API](specifying-kms-encryption.md#KMSUsingRESTAPI)。
## 使用適用於 Java 的 AWS SDK (PutObject)
您可以使用下列範例，使用 適用於 Java 的 AWS SDK在物件層級設定 S3 儲存貯體金鑰。
------
#### [ Java ]
```
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
.withRegion(Regions.DEFAULT_REGION)
.build();
String bucketName = "amzn-s3-demo-bucket1";
String keyName = "key name for object";
String contents = "file contents";
PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, keyName, contents)
.withBucketKeyEnabled(true);
s3client.putObject(putObjectRequest);
```
------
## 使用 AWS CLI (PutObject)
您可以使用下列 AWS CLI 範例，在物件層級設定 S3 儲存貯體金鑰，做為`PutObject`請求的一部分。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key object key name --server-side-encryption aws:kms --bucket-key-enabled --body filepath
```
# 檢視 S3 儲存貯體金鑰的設定
您可以使用 Amazon S3 主控台、REST API、 AWS Command Line Interface (AWS CLI) 或 AWS SDKs，在儲存貯體或物件層級檢視 S3 儲存貯體金鑰的設定。 Amazon S3
S3 儲存貯體金鑰會使用 AWS Key Management Service (SSE-KMS) 減少從 Amazon S3 到 的請求流量， AWS KMS 並降低伺服器端加密的成本。如需詳細資訊，請參閱[使用 Amazon S3 儲存貯體金鑰降低 SSE-KMS 的成本](bucket-key.md)。
若要檢視儲存貯體或已從儲存貯體組態繼承 S3 儲存貯體金鑰設定之物件的 S3 儲存貯體金鑰設定，您需要執行 `s3:GetEncryptionConfiguration` 動作的許可。如需詳細資訊，請參閱 *Amazon Simple Storage Service API 參考*中的 [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)。
## 使用 S3 主控台
在 S3 主控台中，您可以查看儲存貯體或物件的 S3 儲存貯體金鑰設定。除非來源物件已設定 S3 儲存貯體金鑰，否則會從儲存貯體組態繼承 S3 儲存貯體金鑰設定。
同一儲存貯體中的物件和資料夾可以具有不同的 S3 儲存貯體金鑰設定。例如，如果您使用 REST API 上傳物件並為物件啟用 S3 儲存貯體金鑰，則物件會在目的地儲存貯體中保留其 S3 儲存貯體金鑰設定，即使已在目的地儲存貯體中停用 S3 儲存貯體金鑰。另一個範例，如果您為現有儲存貯體啟用 S3 儲存貯體金鑰，則儲存貯體中已存在的物件不會使用 S3 儲存貯體金鑰。但是，新物件啟用了 S3 儲存貯體金鑰。
**檢視儲存佇體的 S3 儲存貯體金鑰設定**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇 **Buckets** (儲存貯體)。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您要啟用 S3 儲存貯體金鑰的儲存貯體。
1. 選擇 **Properties** (屬性)。
1. 在**預設加密**區段，**儲存貯體金鑰**底下，您會看到儲存貯體的 S3 儲存貯體金鑰設定。
如果您看不到 S3 儲存貯體金鑰設定，您可能沒有執行 `s3:GetEncryptionConfiguration` 動作的許可。如需詳細資訊，請參閱*《Amazon Simple Storage Service API 參考》*中的 [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)。
**檢視物件的 S3 儲存貯體金鑰設定**
1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。
1. 在 **Buckets** (儲存貯體) 清單中，選擇您要啟用 S3 儲存貯體金鑰的儲存貯體。
1. 在 **Object (物件)** 清單中，選擇您的物件名稱。
1. 在 **Details (詳細資訊)**標籤的 **Server-side encrption settings (伺服器端加密設定)** 底下，選擇 **Edit (編輯)**。
在**儲存貯體金鑰**之下，您會看到物件的 S3 儲存貯體金鑰設定。您無法編輯此設定。
## 使用 AWS CLI
**傳回儲存貯體層級 S3 儲存貯體金鑰設定**
若要使用此範例，請以您自己的資訊取代每個 `user input placeholder`。
```
aws s3api get-bucket-encryption --bucket amzn-s3-demo-bucket1
```
如需詳細資訊，請參閱《AWS CLI 命令參考》**中的 [get-bucket-encryption](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/get-bucket-encryption.html)。
**傳回 S3 儲存貯體金鑰的物件層級設定**
若要使用此範例，請以您自己的資訊取代每個 `user input placeholder`。
```
aws s3api head-object --bucket amzn-s3-demo-bucket1 --key my_images.tar.bz2
```
如需詳細資訊，請參閱《AWS CLI 命令參考》**中的 [head-object](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/s3api/head-object.html)。
## 使用 REST API
**傳回儲存貯體層級 S3 儲存貯體金鑰設定**
若要傳回儲存貯體的加密資訊，包括 S3 儲存貯體金鑰的設定，請使用 `GetBucketEncryption` 操作。在具有 `BucketKeyEnabled` 設定的 `ServerSideEncryptionConfiguration` 元素中，會在回應內文傳回 S3 儲存貯體金鑰。如需詳細資訊，請參閱 *Amazon S3 API 參考*中的 [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)。
**傳回 S3 儲存貯體金鑰的物件層級設定**
若要傳回物件的 S3 儲存貯體金鑰狀態，請使用 `HeadObject` 操作。`HeadObject` 傳回 `x-amz-server-side-encryption-bucket-key-enabled` 回應標頭以顯示是否以為物件啟用或停用 S3 儲存貯體金鑰。如需詳細資訊，請參閱 *Amazon S3 API 參考*中的 [HeadObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)。
如果已針對物件設定 S3 儲存貯體金鑰，則下列 API 操作也會傳回 `x-amz-server-side-encryption-bucket-key-enabled` 回應標頭：
+ [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [PostObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)
+ [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [CreateMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html)
+ [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html)
+ [UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html)
+ [CompleteMultipartUpload](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html)
+ [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
# 使用雙層伺服器端加密搭配 AWS KMS 金鑰 (DSSE-KMS)
使用雙層伺服器端加密搭配 AWS Key Management Service (AWS KMS) 金鑰 (DSSE-KMS)，會在物件上傳至 Amazon S3 時套用兩層加密。DSSE-KMS 可協助您更輕鬆地達成合規標準，這些標準會要求您將多層加密套用至資料，並完全掌控您的加密金鑰。
DSSE-KMS 中的「雙」是指套用到資料的兩個獨立 AES-256 加密層：
+ *第一層：*您的資料會使用 產生的唯一資料加密金鑰 (DEK) 進行加密 AWS KMS
+ *第二層：*已加密的資料會使用 Amazon S3 管理的個別 AES-256 加密金鑰再次加密
這與標準 SSE-KMS 不同，後者只會套用單一加密層。雙層方法能確保即使一個加密層遭到入侵，您的資料仍會受到第二層的保護，藉以提供增強的安全性。這種額外的安全性帶來了更高的處理開銷和 AWS KMS API 呼叫，與標準 SSE-KMS 相比，其成本更高。如需 DSSE-KMS 定價的詳細資訊，請參閱《 AWS Key Management Service 開發人員指南》中的[AWS KMS key 概念](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#kms_keys)和[AWS KMS 定價](https://aws.amazon.com/kms/pricing)。
當您搭配 Amazon S3 儲存貯體使用 DSSE-KMS 時， AWS KMS 金鑰必須與儲存貯體位於相同的區域。此外，當物件要求 DSSE-KMS 時，做為物件中繼資料一部分的 S3 總和檢查會以加密形式存放。如需總和檢查的詳細資訊，請參閱 [在 Amazon S3 中檢查物件完整性](checking-object-integrity.md)。
**注意**
DSSE-KMS 不支援 S3 儲存貯體金鑰。
DSSE-KMS 與標準 SSE-KMS 之間的主要差異如下：
+ **加密層：**DSSE-KMS 套用兩個獨立的 AES-256 加密層，而標準 SSE-KMS 套用一層
+ **安全性：**DSSE-KMS 提供增強的保護，防範潛在的加密漏洞
+ **合規：**DSSE-KMS 有助於滿足要求多層加密的法規要求
+ **效能：**由於額外的加密處理，DSSE-KMS 的延遲略高
+ **成本：**由於運算開銷增加和其他 AWS KMS 操作，DSSE-KMS 會產生更高的費用
**需要使用 AWS KMS keys (DSSE-KMS) 進行雙層伺服器端加密**
若要在特定 Amazon S3 儲存貯體中要求所有物件的雙層伺服器端加密，您可以使用儲存貯體政策。例如，如果請求不包含要求含 DSSE-KMS 之伺服器端加密的 `x-amz-server-side-encryption` 標頭，則下列儲存貯體政策會拒絕向所有人上傳物件 (`s3:PutObject`) 的許可。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [{
"Sid": "DenyUnEncryptedObjectUploads",
"Effect": "Deny",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"StringNotEquals": {
"s3:x-amz-server-side-encryption": "aws:kms:dsse"
}
}
}
]
}
```
------
**Topics**
+ [
# 使用 AWS KMS 金鑰指定雙層伺服器端加密 (DSSE-KMS)
](specifying-dsse-encryption.md)
# 使用 AWS KMS 金鑰指定雙層伺服器端加密 (DSSE-KMS)
上傳新物件或複製現有物件時，您都可以套用加密。
您可以使用 Amazon S3 主控台、Amazon S3 REST API 和 AWS Command Line Interface (AWS CLI) 來指定 DSSE-KMS。如需詳細資訊，請參閱下列主題。
**注意**
您可以在 Amazon S3 AWS KMS keys 中使用多區域。但是，Amazon S3 目前將多區域金鑰視為單區域金鑰，並且不使用金鑰的多區域功能。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[使用多區域金鑰](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html)。
**注意**
若您想要使用其他帳戶的 KMS 金鑰，您必須具有該金鑰的使用權限。如需詳細了解 KMS 金鑰跨帳戶權限，請參閱《AWS Key Management Service 開發人員指南》**中的[建立其他帳戶可使用的 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/key-policy-modifying-external-accounts.html#cross-account-console)。
## 使用 S3 主控台
本節說明如何設定或變更物件的加密類型，以使用 Amazon S3 主控台搭配 AWS Key Management Service (AWS KMS) 金鑰 (DSSE-KMS) 使用雙層伺服器端加密。
**注意**
如果您的物件小於 5 GB，您可以變更物件的加密。如果您的物件大於 5 GB，您必須使用 [AWS CLI](mpu-upload-object.md#UsingCLImpUpload) 或 [AWS SDK](CopyingObjectsMPUapi.md) 來變更物件的加密。
如需變更物件加密所需的其他許可清單，請參閱[Amazon S3 API 操作所需的許可](using-with-s3-policy-actions.md)。如需授予此許可的範例政策，請參閱[Amazon S3 的身分型政策範例](example-policies-s3.md)。
如果您變更物件的加密，則會建立新物件來取代舊物件。如果啟用 S3 版本控制，則系統會建立物件的新版本，且現有物件會變成較舊的版本。變更屬性的角色也會成為新物件 (或物件版本) 的擁有者。
**新增或變更物件的加密**
1. 登入 AWS 管理主控台 ，並在 https：//[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) 開啟 Amazon S3 主控台。
1. 在導覽窗格中，選擇**儲存貯體**，然後選擇**一般用途儲存貯體**索引標籤。導覽至包含您要變更之物件的 Amazon S3 儲存貯體或資料夾。
1. 選取您要變更之物件的核取方塊。
1. 從**動作**功能表上顯示的選項清單中，選擇**編輯伺服器端加密**。
1. 捲動至**伺服器端加密**區段。
1. 在**加密設定**底下，選擇**使用預設加密的儲存貯體設定**或**覆寫預設加密的儲存貯體設定**。
1. 若您選擇**覆寫預設加密的儲存貯體設定**，請設定下列加密設定。
1. 在**加密類型**下，選擇**具有 AWS Key Management Service 金鑰的雙層伺服器端加密 (DSSE-KMS)**。
1. 在 **AWS KMS 金鑰**之下，執行下列其中一個動作，以選擇 KMS 金鑰：
+ 若要從可用的 KMS 金鑰清單中選擇，請選擇**從 AWS KMS keys中選擇**，然後從可用金鑰清單中選擇您的 **KMS 金鑰**。
AWS 受管金鑰 (`aws/s3`) 和您的客戶受管金鑰都會顯示在此清單中。如需詳細了解客戶受管金鑰，請參閱《AWS Key Management Service 開發人員指南》**中的[客戶金鑰和 AWS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#key-mgmt)。
+ 若要輸入 KMS 金鑰 ARN，請選擇**輸入 AWS KMS key ARN**，然後在出現的欄位中輸入您的 KMS 金鑰 ARN。
+ 若要在 AWS KMS 主控台中建立新的客戶受管金鑰，請選擇**建立 KMS 金鑰**。
如需建立 的詳細資訊 AWS KMS key，請參閱《 *AWS Key Management Service 開發人員指南*》中的[建立金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/create-keys.html)。
**重要**
您只能使用在與儲存貯體相同的 AWS 區域 中可用的 KMS 金鑰。Amazon S3 主控台僅會列出與儲存貯體位於相同區域的前 100 個 KMS 金鑰。若要使用未列出的 KMS 金鑰，必須輸入 KMS 金鑰 ARN。若您想要使用其他帳戶的 KMS 金鑰，您必須先具有該金鑰的使用權限，然後輸入 KMS 金鑰 ARN。
Amazon S3 僅支援對稱加密 KMS 金鑰，而不支援非對稱 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[識別非對稱 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/find-symm-asymm.html)。
1. 在**儲存貯體金鑰**下，選擇**停用**。DSSE-KMS 不支援 S3 儲存貯體金鑰。
1. 在**其他複製設定**下，選擇**複製來源設定**、**不要指定設定**或**指定設定**。**複製來源設定**是預設選項。如果您只想複製物件但不想包含來源設定屬性，請選擇**不要指定設定**。選擇**指定設定**以指定儲存類別、ACL、物件標籤、中繼資料、伺服器端加密和額外檢查總和的設定。
1. 選擇 **Save changes** (儲存變更)。
**注意**
此動作會將加密套用至所有指定的物件。加密資料夾時，請等待儲存作業完成，然後再將新物件新增至資料夾。
## 使用 REST API
當您建立物件時，也就是當您上傳新物件或複製現有物件時，您可以指定使用雙層伺服器端加密搭配 AWS KMS keys (DSSE-KMS) 來加密資料。若要執行這項操作，請將 `x-amz-server-side-encryption` 標頭新增至要求。將標頭的值設為加密演算法 `aws:kms:dsse`。Amazon S3 會傳回回應標頭 `x-amz-server-side-encryption`，確認已使用 DSSE-KMS 加密存放物件。
如果您使用 `aws:kms:dsse` 的值指定 `x-amz-server-side-encryption` 標頭，也可以使用下列要求標頭：
+ `x-amz-server-side-encryption-aws-kms-key-id: SSEKMSKeyId`
+ `x-amz-server-side-encryption-context: SSEKMSEncryptionContext`
**Topics**
+ [
### 支援 DSSE-KMS 的 Amazon S3 REST API 操作
](#dsse-request-headers-kms)
+ [
### 加密內容 (`x-amz-server-side-encryption-context`)
](#s3-dsse-encryption-context)
+ [
### AWS KMS 金鑰 ID (`x-amz-server-side-encryption-aws-kms-key-id`)
](#s3-dsse-key-id-api)
### 支援 DSSE-KMS 的 Amazon S3 REST API 操作
下列 REST API 操作接受 `x-amz-server-side-encryption`、`x-amz-server-side-encryption-aws-kms-key-id` 和 `x-amz-server-side-encryption-context` 請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) – 使用 `PUT` API 操作上傳資料時，您可以指定這些請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html) – 複製物件時，您會同時有來源物件與目標物件。當您使用 `CopyObject` 操作傳遞 DSSE-KMS 標頭時，這些標頭只會套用至目標物件。複製現有物件時，除非明確地要求伺服器端加密，否則無論來源物件是否經過加密，都不會加密目標物件。
+ [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html) – 使用 `POST` 操作上傳物件時，您會提供與表單欄位中相同的資訊，而不是請求標頭。
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html) – 透過分段上傳來上傳大型物件時，您可以在 `CreateMultipartUpload` 請求中指定這些標頭。
使用伺服器端加密存放物件時，下列 REST API 操作的回應標頭會傳回 `x-amz-server-side-encryption` 標頭。
+ [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_CopyObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)
+ [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.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_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)
+ [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/API_GetObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html)
**重要**
如果您未使用 Secure Sockets Layer (SSL)、Transport Layer Security (TLS) 或 Signature 第 4 版，則受 保護物件的所有 `GET`和 `PUT`請求都會 AWS KMS 失敗。
如果您的物件使用 DSSE-KMS，請勿傳送 `GET` 請求與 `HEAD` 請求的加密請求標頭，否則您會收到 HTTP 400 (錯誤的請求) 錯誤。
### 加密內容 (`x-amz-server-side-encryption-context`)
如果您指定 `x-amz-server-side-encryption:aws:kms:dsse`，則 Amazon S3 API 支援具有 `x-amz-server-side-encryption-context` 標頭的加密內容。加密內容是一組金鑰值對，其中包含資料的其他相關內容資訊。
Amazon S3 會自動使用物件的 Amazon Resource Name (ARN) 作為加密內容配對，例如 `arn:aws:s3:::object_ARN`。
您可以使用 `x-amz-server-side-encryption-context` 標頭來提供其他加密內容對。不過，加密內容未加密，因此請確保其中不包含敏感資訊。Amazon S3 會一起存放此附加金鑰對與預設加密內容。
如需 Amazon S3 中加密內容的相關資訊，請參閱 [加密內容](UsingKMSEncryption.md#encryption-context)。如需有關加密內容的更多資訊，請參閱《AWS Key Management Service 開發人員指南》**中的 [AWS Key Management Service 概念：加密內容](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context)。
### AWS KMS 金鑰 ID (`x-amz-server-side-encryption-aws-kms-key-id`)
您可以使用 `x-amz-server-side-encryption-aws-kms-key-id` 標頭來指定用來保護資料之客戶受管金鑰的 ID。如果您指定 `x-amz-server-side-encryption:aws:kms:dsse`標頭，但未提供 `x-amz-server-side-encryption-aws-kms-key-id`標頭，Amazon S3 會使用 AWS 受管金鑰 (`aws/s3`) 來保護資料。如果您想要使用客戶受管的金鑰，則必須提供客戶受管金鑰的 `x-amz-server-side-encryption-aws-kms-key-id` 標頭。
**重要**
當您在 Amazon S3 中使用 AWS KMS key 進行伺服器端加密時，您必須選擇對稱加密 KMS 金鑰。Amazon S3 只支援對稱加密 KMS 金鑰。如需詳細資訊，請參閱《AWS Key Management Service 開發人員指南》**中的[對稱加密 KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#symmetric-cmks)。
## 使用 AWS CLI
當上傳新物件或複製現有物件時，您可以指定使用 DSSE-KMS 來加密資料。若要執行這項操作，請將 `--server-side-encryption aws:kms:dsse` 參數新增至請求。使用 `--ssekms-key-id example-key-id` 參數來新增您已建立的[客戶受管 AWS KMS 金鑰](https://docs.aws.amazon.com//kms/latest/developerguide/concepts.html#customer-cmk)。如果您指定 `--server-side-encryption aws:kms:dsse`，但未提供 AWS KMS 金鑰 ID，則 Amazon S3 將使用 AWS 受管金鑰 (`aws/s3`)。
```
aws s3api put-object --bucket amzn-s3-demo-bucket --key example-object-key --server-side-encryption aws:kms:dsse --ssekms-key-id example-key-id --body filepath
```
您可以將未加密的物件加密以使用 DSSE-KMS，方法是將物件複製回原位。
```
aws s3api copy-object --bucket amzn-s3-demo-bucket --key example-object-key --copy-source amzn-s3-demo-bucket/example-object-key --server-side-encryption aws:kms:dsse --ssekms-key-id example-key-id
```
# 搭配客戶提供的金鑰 (SSE-C) 使用伺服器端加密
伺服器端加密是有關保護靜態資料。伺服器端加密只會加密物件資料，非物件中繼資料。您可以在一般用途儲存貯體中使用伺服器端加密搭配客戶提供的金鑰 (SSE-C)，以使用您自己的加密金鑰來加密資料。如果您提供的加密金鑰作為請求的一部分，Amazon S3 會在資料寫入磁碟時管理資料加密，以及在您存取物件時管理資料解密。因此，您不需要維護任何程式碼來執行資料加密與解密。您只需要管理自己提供的加密金鑰即可。
Amazon S3 中的大多數現代使用案例都不再使用 SSE-C，因為它缺乏使用 Amazon S3 受管金鑰 (SSE-S3) 進行伺服器端加密的靈活性，或使用 AWS KMS 金鑰 (SSE-KMS) 進行伺服器端加密的靈活性。每次與 SSE-C 加密資料互動時，SSE-C 需要提供加密金鑰，因此與從 S3 儲存貯體讀取資料的其他使用者、角色 AWS 或服務共用 SSE-C 金鑰，以便操作您的資料並不切實際。由於對 SSE-KMS 的廣泛支援 AWS，大多數現代工作負載不會使用 SSE-C 加密，因為它缺乏 SSE-KMS 的靈活性。若要進一步了解 SSE-KMS，請參閱 [搭配 AWS KMS 金鑰使用伺服器端加密 (SSE-KMS)](UsingKMSEncryption.md)。
如果您想要防止 SSE-C 加密用於寫入儲存貯體的物件，您可以在變更儲存貯體的預設加密組態時封鎖 SSE-C 加密。當一般用途儲存貯體封鎖 SSE-C `CopyObject`時，任何指定 SSE-C 加密的 `PutObject`、`PostObject`、、分段上傳或複寫請求都會遭到拒絕，並顯示`HTTP 403 AccessDenied`錯誤。若要進一步了解如何封鎖 SSE-C，請參閱 [封鎖或取消封鎖一般用途儲存貯體的 SSE-C](blocking-unblocking-s3-c-encryption-gpb.md)。
使用 SSE-C 無須額外付費。不過，請求設定和使用 SSE-C 會產生標準的 Amazon S3 請求費用。如需定價的資訊，請參閱 [Amazon S3 定價](https://aws.amazon.com/s3/pricing/)。
**重要**
如 [2025 年 11 月 19 日所宣布](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 正在部署新的預設儲存貯體安全設定，以針對所有新的一般用途儲存貯體自動停用使用客戶提供金鑰 (SSE-C) 的伺服器端加密。對於 中沒有 SSE-C 加密物件 AWS 帳戶 的現有儲存貯體，Amazon S3 也會為所有新的寫入請求停用 SSE-C。對於 AWS 帳戶 使用 SSE-C 的 ，Amazon S3 不會變更這些帳戶中任何現有儲存貯體的儲存貯體加密組態。此部署從 2026 年 4 月 6 日開始，並將在接下來的幾週內在 37 AWS 個區域完成，包括 AWS 中國和 AWS GovCloud (US) 區域。
透過這些變更，需要 SSE-C 加密的應用程式在建立新的儲存貯體之後，必須使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作刻意啟用 SSE-C。如需此變更的詳細資訊，請參閱 [新儲存貯體的預設 SSE-C 設定常見問答集](default-s3-c-encryption-setting-faq.md)。
## 使用 SSE-C 之前的考量事項
+ 當您使用 SSE-C 時，S3 永遠不會存放加密金鑰。 每次您希望任何人從 S3 下載 SSE-C 加密資料時，都必須提供加密金鑰。
+ 您會管理哪個加密金鑰用來加密哪個物件的對應。您會負責追蹤針對哪個物件提供哪個加密金鑰。這也表示如果您遺失加密金鑰，則會遺失物件。
+ 由於您是在用戶端管理加密金鑰，因此您會在用戶端管理任何額外的保護措施，例如金鑰輪替。
+ 這種設計可能會讓您難以與其他使用者、角色 AWS 或服務共用 SSE-C 金鑰，以便在資料上操作。由於對 SSE-KMS 的廣泛支援 AWS，大多數現代工作負載不會使用 SSE-C，因為它缺乏 SSE-KMS 的靈活性。若要進一步了解 SSE-KMS，請參閱[使用伺服器端加密搭配 AWS KMS 金鑰 (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)。
+ 這表示使用 SSE-C 加密的物件無法由 AWS 受管服務原生解密。
+ 在請求上指定 SSE-C 標頭時，您必須使用 HTTPS。
+ 使用 SSE-C 時，Amazon S3 會拒絕所有透過 HTTP 提出的請求。為安全起見，建議任何錯誤地透過 HTTP 傳送的金鑰皆視為已遭洩漏。請捨棄該金鑰，並適當地輪換。
+ 如果您的儲存貯體已啟用版本控制，您上傳的每個物件版本都可以有自己的加密金鑰。您會負責追蹤針對哪個物件版本使用了哪個加密金鑰。
+ Amazon S3 主控台不支援 SSE-C。您無法使用 Amazon S3 主控台上傳物件並指定 SSE-C 加密。您也無法使用主控台來更新使用 SSE-C 存放的現有物件 (例如變更儲存方案或新增中繼資料)。
**Topics**
+ [
## 使用 SSE-C 之前的考量事項
](#considerations-before-using-sse-c)
+ [
# 使用客戶提供金鑰 (SSC-C) 指定伺服器端加密
](specifying-s3-c-encryption.md)
+ [
# 封鎖或取消封鎖一般用途儲存貯體的 SSE-C
](blocking-unblocking-s3-c-encryption-gpb.md)
+ [
# 新儲存貯體的預設 SSE-C 設定常見問答集
](default-s3-c-encryption-setting-faq.md)
# 使用客戶提供金鑰 (SSC-C) 指定伺服器端加密
若要搭配客戶提供的金鑰 (SSE-C) 使用伺服器端加密，請先確定 SSE-C 不是 Amazon S3 一般用途儲存貯體的預設加密組態中的封鎖加密類型。如果封鎖，您可以透過更新儲存貯體的預設加密組態來啟用此加密類型。然後，您可以透過傳遞所需的標頭，在上傳請求中使用 SSE-C。請參閱 [支援使用 SSE-C 寫入資料的 Amazon S3 動作](#amazon-s3-actions-that-support-writing-data-with-sse-c)，並確保包含 [SSE-C 物件加密和解密請求所需的 S3 API 標頭](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)。
當您上傳指定 SSE-C 的物件時，Amazon S3 會使用您提供的加密金鑰，將 AES-256 加密套用至您的資料。然後，Amazon S3 會從記憶體中移除加密金鑰。當您擷取物件時，您必須在要求中提供相同的加密金鑰。Amazon S3 會先驗證您提供的加密金鑰是否相符，然後對物件進行解密，再將物件資料傳回給您。
使用 SSE-C 之前，請確定您已檢閱 [使用 SSE-C 之前的考量事項](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c)。
**注意**
Amazon S3 不會存放您提供的加密金鑰。相反地，它會存放加密金鑰的隨機雜湊訊息驗證碼 (HMAC) Salt 值，以驗證未來的請求。HMAC Salt 值不可用來衍生加密金鑰的值，或用來對加密物件的內容進行解密。換句話說，如果您遺失加密金鑰，則會遺失物件。
**Topics**
+ [
## SSE-C 動作和必要標頭
](#sse-c-actions-and-required-headers)
+ [
## 強制 SSE-C 加密的儲存貯體政策範例
](#example-bucket-policy-to-enforce-sse-c-encryption)
+ [
## 已預先簽章的 URL 和 SSE-C
](#ssec-and-presignedurl)
+ [
## 使用 SSE-C 提出請求
](#making-requests-with-sse-c)
+ [
## 使用 REST API
](#using-rest-api-sse-c)
+ [
## 使用 AWS SDKs為 PUT、GET、頭部和複製操作指定 SSE-C
](#sse-c-using-sdks)
+ [
## 使用 AWS SDKs為分段上傳指定 SSE-C
](#sse-c-using-sdks-multipart-uploads)
## SSE-C 動作和必要標頭
在支援的 S3 APIs 上指定 SSE-C 需要傳遞特定請求參數。
**注意**
Amazon S3 中的 `PutBucketEncryption` API 用於設定儲存貯體的預設伺服器端加密。不過， `PutBucketEncryption` 不支援啟用 SSE-C 做為儲存貯體的預設加密方法。SSE-C 是一種物件層級加密方法，可讓您在每次物件上傳或下載請求時，將加密金鑰提供給 Amazon S3。Amazon S3 使用此金鑰在請求期間加密或解密物件，然後捨棄金鑰。這表示 SSE-C 是以每個物件為基礎啟用，而不是做為預設儲存貯體設定。
### 支援使用 SSE-C 寫入資料的 Amazon S3 動作
您可以使用下列 API 操作或動作，在將物件寫入一般用途儲存貯體時，使用客戶提供的金鑰 (SSE-C) 請求伺服器端加密：
+ [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)
**注意**
S3 複寫支援使用 SSE-C 加密的物件。如需複寫加密物件的詳細資訊，請參閱 [複寫加密的物件 (SSE-S3、SSE-KMS、DSSE-KMS、SSE-C)](replication-config-for-kms-objects.md)。
### SSE-C 物件加密和解密請求所需的 S3 API 標頭
您必須提供下列三個 API 標頭，以使用 SSE-C 加密或解密物件：
+ `x-amz-server-side-encryption-customer-algorithm` 使用此標頭來指定加密演算法。標頭值必須為 AES256。
+ `x-amz-server-side-encryption-customer-key` 使用此標頭提供 256 位元的 base64 編碼加密金鑰，讓 Amazon S3 用來加密或解密您的資料。
+ `x-amz-server-side-encryption-customer-key-MD5` 使用此標頭可根據 RFC 1321 提供加密金鑰的 base64 編碼 128 位元 MD5 摘要。Amazon S3 使用此標頭來進行訊息完整性檢查，以確保加密金鑰傳輸無誤。
### 請求複製使用 SSE-C 加密的來源物件所需的 S3 API 標頭
您必須提供下列三個 API 標頭，才能複製使用 SSE-C 加密的來源物件：
+ `x-amz-copy-source-server-side-encryption-customer-algorithm` 包含此標頭來指定 Amazon S3 應該用來解密來源物件的演算法。此值必須是 AES256。
+ `x-amz-copy-source-server-side-encryption-customer-key` 包含此標頭以提供 base64 編碼的加密金鑰，供 Amazon S3 用來解密來源物件。此加密金鑰必須是您建立來源物件時提供給 Amazon S3 的加密金鑰。否則，Amazon S3 無法解密物件。
+ `x-amz-copy-source-server-side-encryption-customer-key-MD5` 包含此標頭，以提供根據 RFC 1321 加密金鑰的 base64 編碼 128 位元 MD5 摘要。
## 強制 SSE-C 加密的儲存貯體政策範例
若要針對寫入 Amazon S3 儲存貯體的所有物件要求 SSE-C，您可以使用儲存貯體政策。例如，下列儲存貯體政策拒絕所有不包含請求 SSE-C 之 `x-amz-server-side-encryption-customer-algorithm` 標題請求的上傳物件 (`s3:PutObject`) 許可。
```
{
"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"
}
}
}
]
}
```
**重要**
如果您使用儲存貯體政策在`s3:PutObject` 上要求 SSE-C，則必須在所有分段上傳請求中包含 `x-amz-server-side-encryption-customer-algorithm` 標頭 (CreateMultipartUpload、UploadPart 和 CompleteMultipartUpload)。
## 已預先簽章的 URL 和 SSE-C
您可以產生預先簽章的 URL，其可以用於上傳新的物件、擷取現有的物件或擷取物件中繼資料等操作。預先簽章的 URL 支援如下的 SSE-C：
+ 建立預先簽章的 URL 時，您必須在簽章計算中使用 `x-amz-server-side-encryption-customer-algorithm` 標頭來指定演算法。
+ 使用預先簽章的 URL 來上傳新的物件、擷取現有的物件或只擷取物件中繼資料時，您必須提供用戶端應用程式請求中的所有加密標頭。
**注意**
針對非 SSE-C 物件，您可以產生預先簽章的 URL，並將該 URL 直接貼入至瀏覽器以存取資料。
不過，您無法針對 SSE-C 物件執行此操作，因為除了預先簽章的 URL 之外，您亦須包含 SSE-C 物件專屬的 HTTP 標頭。因此，您只能以程式設計方式針對 SSE-C 物件使用預先簽章的 URL。
如需預先簽章的 URL 詳細資訊，請參閱[使用預先簽章的 URL 來下載和上傳物件](using-presigned-url.md)。
## 使用 SSE-C 提出請求
在使用 REST API 建立物件時，您可以使用客戶提供的金鑰 (SSE-C) 來指定伺服器端加密。使用 SSE-C 時，您必須使用 提供加密金鑰資訊[請求複製使用 SSE-C 加密的來源物件所需的 S3 API 標頭](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c)。您可以使用 AWS SDK 包裝函式程式庫將這些標頭新增至您的請求。如果需要，您可以直接在應用程式中進行 Amazon S3 REST API 呼叫。
**重要**
使用客戶提供的金鑰 (SSE-C) 指定伺服器端加密之前，請確定您的一般用途儲存貯體不會封鎖 SSE-C 加密。如需詳細資訊，請參閱[封鎖或取消封鎖一般用途儲存貯體的 SSE-C](blocking-unblocking-s3-c-encryption-gpb.md)。
**注意**
您無法使用 Amazon S3 主控台上傳物件並請求 SSE-C。 您也無法使用 主控台來更新 （例如，變更儲存類別或新增中繼資料） 使用 SSE-C 存放的現有物件。 如需詳細資訊，請參閱 [SSE-C 物件加密和解密請求所需的 S3 API 標頭](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)。
## 使用 REST API
### 支援 SSE-C 的 Amazon S3 REST API APIs
下列 Amazon S3 API 支援伺服器端加密搭配客戶提供的加密金鑰 (SSE-C)。
+ **GET 操作** – 使用 GET API 擷取物件時 (請參閱 [GET 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html))，您可以指定這些請求標頭。
+ **HEAD 操作** – 若要使用 HEAD API 擷取物件中繼資料 (請參閱 [HEAD 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html))，您可以指定這些請求標頭。
+ **PUT 操作** – 使用 PUT API 上傳資料時 (請參閱 [PUT 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html))，您可以指定這些請求標頭。
+ **分段上傳** – 使用分段上傳 API 上傳大型物件時，您可以指定這些標頭。您可以在啟動請求 （請參閱[啟動分段上傳](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)) 和每個後續分段上傳請求 （請參閱[上傳部分](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html)或 [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)) 中指定這些標頭。每個部分上傳要求的加密資訊，必須與您在啟動分段上傳要求中所提供的加密資訊相同。
+ **POST 操作** – 使用 POST 操作上傳物件時 (請參閱 [POST 物件](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html))，請提供與表單欄位中相同的資訊，而不是請求標頭。
+ **複製操作** – 當您複製物件 （請參閱 [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)) 時，您會同時擁有來源物件和目標物件：
+ 如果您想要指定目標物件的加密類型，您必須提供`x-amz-server-side-encryption `請求標頭。
+ 如果您想要使用 SSE-C 加密目標物件，您必須使用 S3 API 提供加密資訊[SSE-C 物件加密和解密請求所需的 S3 API 標頭](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)。
+ 如果來源物件是使用 SSE-C 加密，您必須使用 S3 API 標頭 提供加密金鑰資訊[請求複製使用 SSE-C 加密的來源物件所需的 S3 API 標頭](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c)。
## 使用 AWS SDKs為 PUT、GET、頭部和複製操作指定 SSE-C
下列範例說明如何用客戶提供金鑰 (SSE-C)，要求為物件進行伺服器端加密。這些範例會執行下列操作。每個操作示範如何在要求中指定 SSE-C 相關標頭：
+ **放置物件** – 使用客戶提供的加密金鑰上傳物件並請求伺服器端加密。
+ **取得物件** – 下載前一個步驟中所上傳的物件。在此請求中，請您提供在您上傳物件時所提供的相同加密資訊。Amazon S3 需要此資訊來解密物件，才能將物件傳回給您。
+ **取得物件中繼資料** – 擷取物件的中繼資料。請您提供物件建立時，使用的加密資訊。
+ **複製物件** – 建立先前上傳物件的複本。因為來源物件是使用 SSE-C 所存放，所以您必須在複製要求中提供其加密資訊。根據預設，只有在您明確請求加密時，Amazon S3 才會加密物件的複本。此範例指示 Amazon S3 存放加密的物件複本。
------
#### [ Java ]
**注意**
此範例示範如何以單一操作上傳物件。使用分段上傳 API 上傳大型物件時，請您提供如此範例一樣的加密資訊。如需使用 的分段上傳範例 適用於 Java 的 AWS SDK，請參閱 [使用分段上傳來上傳物件](mpu-upload-object.md)。
新增要求加密資訊，您可包含 `SSECustomerKey` 在您的要求中。如需有關 `SSECustomerKey` 類別的詳細資訊，請參閱 REST API 一節。
如需建立和測試工作範例的說明，請參閱《 適用於 Java 的 AWS SDK 開發人員指南》中的[入門](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html)。
**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 ]
**注意**
如需更說使用分段上傳 API 大型物件的範例，請參閱 [使用分段上傳來上傳物件](mpu-upload-object.md) 和 [使用 AWS SDKs（低階 API)](mpu-upload-object.md#mpu-upload-low-level)。
如需有關設定和執行程式碼範例的資訊，請參閱《[適用於 .NET 的 AWS SDK 開發人員指南》中的適用於 .NET 的 SDK 入門](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html)。 *AWS *
**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);
}
}
}
```
------
## 使用 AWS SDKs為分段上傳指定 SSE-C
上節中的範例示範如何以 PUT、GET、Head 和 Copy 操作要求經由客戶提供加密金鑰的伺服器端加密 (SSE-C)。本節說明其他支援 SSE-C 的 Amazon S3 API。
------
#### [ Java ]
若要上傳大型物件，您可以使用分段上傳 APIs。如需詳細資訊，請參閱[在 Amazon S3 中使用分段上傳來上傳和複製物件](mpuoverview.md)。您可以使用高階或低階 API 來上傳大型物件。這些 API 支援要求中的加密相關標頭。
+ 使用高階 `TransferManager` API 時，您可以在 中提供加密特定的標頭`PutObjectRequest`。如需詳細資訊，請參閱[使用分段上傳來上傳物件](mpu-upload-object.md)。
+ 使用低階 API 時，請您在 `InitiateMultipartUploadRequest` 提供加密關聯資訊，遵照 `UploadPartRequest` 中每一個的相同加密資訊。您不需要在 `CompleteMultipartUploadRequest` 提供任何加密特定標頭。如需範例，請參閱 [使用 AWS SDKs（低階 API)](mpu-upload-object.md#mpu-upload-low-level)。
下列範例使用 `TransferManager` 建立物件，並示範如何提供 SSE-C 相關資訊。此範例執行下列操作：
+ 使用 `TransferManager.upload()` 方法建立物件。在`PutObjectRequest`執行個體中，您會在請求中提供加密金鑰資訊。Amazon S3 會使用客戶提供的金鑰來加密物件。
+ 呼叫 `TransferManager.copy()` 方法，以建立物件的複本。此範例指示 Amazon S3 使用新的 `SSECustomerKey` 來加密物件複本。因為來源物件使用 SSE-C 加密，所以 `CopyObjectRequest` 也會提供來源物件的加密金鑰，讓 Amazon S3 可以先解密物件，再進行複製。
**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 ]
若要上傳大型物件，您可以使用分段上傳 API （請參閱 [在 Amazon S3 中使用分段上傳來上傳和複製物件](mpuoverview.md))。 AWS SDK for .NET 提供高階或低階 APIs 來上傳大型物件。這些 API 支援要求中的加密相關標頭。
+ 使用高階 `Transfer-Utility `API 時，您在 `TransferUtilityUploadRequest` 所提供的加密特定標頭，如下所示。如需程式碼範例，請參閱 [使用分段上傳來上傳物件](mpu-upload-object.md)。
```
TransferUtilityUploadRequest request = new TransferUtilityUploadRequest()
{
FilePath = filePath,
BucketName = existingBucketName,
Key = keyName,
// Provide encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
```
+ 使用低階 API 時，請提供您在啟動分段上傳要求中的加密相關資訊，後面接著後續分段上傳要求中的相同加密資訊。您不需要在完整的分段上傳要求中提供任何加密特定標頭。如需範例，請參閱 [使用 AWS SDKs（低階 API)](mpu-upload-object.md#mpu-upload-low-level)。
以下為建立現有大型物件複本的低階分段上傳範例。在此範例中，要複製的物件會使用 SSE-C 存放在 Amazon S3 中，而您也想要使用 SSE-C 儲存目標物件。在此範例中，您要執行以下動作：
+ 提供加密金鑰與相關資訊，以啟動分段上傳要求。
+ 在 `CopyPartRequest` 中提供來源與目標物件加密金鑰以及相關資訊。
+ 擷取物件中繼資料，以取得要複製之來源物件的大小。
+ 將物件分成 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);
}
}
}
}
```
------
# 封鎖或取消封鎖一般用途儲存貯體的 SSE-C
Amazon S3 中的大多數現代使用案例不再搭配客戶提供的金鑰 (SSE-C) 使用伺服器端加密，因為它缺乏使用 Amazon S3 受管金鑰 (SSE-S3) 的伺服器端加密或 AWS KMS 金鑰 (SSE-KMS) 的伺服器端加密彈性。每次與 SSE-C 加密資料互動時，SSE-C 需要提供加密金鑰，因此與從 S3 儲存貯體讀取資料的其他使用者、角色 AWS 或服務共用 SSE-C 金鑰，以便操作您的資料並不切實際。
若要限制您可以在一般用途儲存貯體中使用的伺服器端加密類型，您可以選擇透過更新儲存貯體的預設加密組態來封鎖 SSE-C 寫入請求。此儲存貯體層級組態會封鎖上傳指定 SSE-C 物件的請求。 當儲存貯體的 SSE-C 遭到封鎖時，任何指定 SSE-C 加密的 `PutObject`、`CopyObject``PostObject`、 或 分段上傳或複寫請求都會遭到 HTTP 403 `AccessDenied`錯誤拒絕。
此設定是 `PutBucketEncryption` API 上的參數，如果您有 `s3:PutEncryptionConfiguration`許可，也可以使用 S3 主控台、 AWS CLI 和 AWS SDKs進行更新。
有效值為 `SSE-C`，可封鎖一般用途儲存貯體的 SSE-C 加密，以及 `NONE`，允許使用 SSE-C 寫入儲存貯體。
**重要**
如 [2025 年 11 月 19 日所宣布](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 正在部署新的預設儲存貯體安全設定，以針對所有新的一般用途儲存貯體自動停用使用客戶提供金鑰 (SSE-C) 的伺服器端加密。對於 中沒有 SSE-C 加密物件 AWS 帳戶 的現有儲存貯體，Amazon S3 也會為所有新的寫入請求停用 SSE-C。對於 AWS 帳戶 使用 SSE-C 的 ，Amazon S3 不會變更這些帳戶中任何現有儲存貯體的儲存貯體加密組態。此部署從 2026 年 4 月 6 日開始，並將在接下來的幾週內在 37 AWS 個區域完成，包括 AWS 中國和 AWS GovCloud (US) 區域。
透過這些變更，需要 SSE-C 加密的應用程式在建立新的儲存貯體之後，必須使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作刻意啟用 SSE-C。如需此變更的詳細資訊，請參閱 [新儲存貯體的預設 SSE-C 設定常見問答集](default-s3-c-encryption-setting-faq.md)。
## 許可
使用 `PutBucketEncryption` API 或 S3 主控台、 AWS SDKs或 AWS CLI 來封鎖或取消封鎖一般用途儲存貯體的加密類型。您必須擁有下列許可：
+ `s3:PutEncryptionConfiguration`
使用 `GetBucketEncryption` API 或 S3 主控台、 AWS SDKs或 AWS CLI 來檢視一般用途儲存貯體的封鎖加密類型。您必須擁有下列許可：
+ `s3:GetEncryptionConfiguration`
## 封鎖 SSE-C 加密之前的考量事項
封鎖任何儲存貯體的 SSE-C 之後，會套用下列加密行為：
+ 在您封鎖 SSE-C 加密之前，儲存貯體中已存在之物件的加密沒有變更。
+ 封鎖 SSE-C 加密之後，只要您在請求上提供必要的 SSE-C 標頭，您就可以繼續對使用 SSE-C 加密的現有物件提出 GetObject 和 HeadObject 請求。
+ 當儲存貯體的 SSE-C 遭到封鎖時，任何指定 SSE-C `PutObject` `CopyObject`加密的 `PostObject`、、 或 分段上傳請求都會因 HTTP 403 `AccessDenied`錯誤而遭到拒絕。
+ 如果複寫的目的地儲存貯體已封鎖 SSE-C，且複寫的來源物件已使用 SSE-C 加密，複寫將會失敗，並顯示 HTTP 403 `AccessDenied`錯誤。
如果您想要在封鎖此加密類型之前，檢閱您是否在任何儲存貯體中使用 SSE-C 加密，您可以使用 [AWS CloudTrail](https://aws.amazon.com/cloudtrail/) 等工具來監控對資料的存取。此[部落格文章](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/)說明如何即時稽核物件上傳的加密方法。您也可以參考此 [re：Post 文章](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets)，引導您完成查詢 S3 庫存報告，以查看是否有任何 SSE-C 加密物件。
### 步驟
您可以使用 Amazon S3 主控台、 AWS Command Line Interface ()、Amazon S3 REST API 和 AWS SDKs，針對一般用途儲存貯體使用客戶提供的金鑰 (SSE-C AWS CLI) 來封鎖或取消封鎖伺服器端加密。
### 使用 S3 主控台
若要使用 Amazon S3 主控台封鎖或取消封鎖儲存貯體的 SSE-C 加密：
1. 登入 AWS 管理主控台，並在 https://console.aws.amazon.com/s3/：// 開啟 Amazon S3 主控台。
1. 在左側導覽窗格中，選擇**一般用途儲存貯**體。
1. 選取您要封鎖 SSE-C 加密的儲存貯體。
1. 選取儲存貯體的**屬性**索引標籤。
1. 導覽至儲存貯體**的預設加密**屬性面板，然後選取**編輯**。
1. 在**封鎖加密類型**區段中，核取**使用客戶提供金鑰 (SSE-C) 的伺服器端加密**旁的方塊，以封鎖 SSE-C 加密，或取消核取此方塊以允許 SSE-C。
1. 選取 **Save Changes** (儲存變更)。
### 使用 AWS CLI
若要安裝 AWS CLI，請參閱《 [AWS 使用者指南》中的安裝 CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)。 *AWS Command Line Interface *
下列 CLI 範例說明如何使用 來封鎖或取消封鎖一般用途儲存貯體的 SSE-C 加密 AWS CLI。若要使用此命令，請以您自己的資訊取代*使用者輸入預留位置*。
**請求封鎖一般用途儲存貯體的 SSE-C 加密：**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "SSE-C"
}
}]
}'
```
**請求在一般用途儲存貯體上使用 SSE-C 加密：**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "NONE"
}
}]
}'
```
## 使用 AWS SDKs
------
#### [ SDK for Java 2.x ]
下列範例說明如何使用 AWS SDKs 封鎖或取消封鎖 SSE-C 加密寫入您的一般用途儲存貯體
**範例 - PutBucketEncryption 請求將預設加密組態設定為 SSE-S3 並封鎖 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)));
```
**範例 - PutBucketEncryption 請求將預設加密組態設定為 SSE-S3 並解除封鎖 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 ]
**範例 - PutBucketEncryption 請求將預設加密組態設定為 SSE-S3 並封鎖 SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["SSE-C"]
}
}]
}
)
```
**範例 - PutBucketEncryption 請求將預設加密組態設定為 SSE-S3 並解除封鎖 SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["NONE"]
}
}]
}
)
```
------
## 使用 REST API
如需有關 Amazon S3 REST API 支援為一般用途儲存貯體破解或取消封鎖 SSE-C 加密的資訊，請參閱《*Amazon Simple Storage Service API 參考*》中的下列章節：
+ 在 [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) 和 GetBucketEncryption API 操作的 ServerSideEncryptionRule 資料類型中使用的 [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html) 資料類型。 [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html) [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)
# 新儲存貯體的預設 SSE-C 設定常見問答集
**重要**
如 [2025 年 11 月 19 日所宣布](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 正在部署新的預設儲存貯體安全設定，以針對所有新的一般用途儲存貯體自動停用使用客戶提供金鑰 (SSE-C) 的伺服器端加密。對於 中沒有 SSE-C 加密物件 AWS 帳戶 的現有儲存貯體，Amazon S3 也會為所有新的寫入請求停用 SSE-C。對於 AWS 帳戶 使用 SSE-C 的 ，Amazon S3 不會變更這些帳戶中任何現有儲存貯體的儲存貯體加密組態。此部署從 2026 年 4 月 6 日開始，並將在接下來的幾週內在 37 AWS 個區域完成，包括 AWS 中國和 AWS GovCloud (US) 區域。
透過這些變更，需要 SSE-C 加密的應用程式必須在建立新儲存貯體後，使用 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作刻意啟用 SSE-C。
以下各節回答有關此更新的問題。
**1。在 2026 年 4 月，新的 SSE-C 設定會對所有新建立的儲存貯體生效嗎？**
是。此部署從 2026 年 4 月 6 日開始，並將在接下來的幾週內在 37 AWS 個區域完成，包括 AWS 中國和 AWS GovCloud (US) 區域。
**注意**
部署完成後，除了中東 （巴林） 和中東 （阿拉伯聯合大公國） 以外的所有 AWS 區域中新建立的儲存貯體預設會停用 SSE-C。
**2. 在此推展涵蓋所有 AWS 區域之前，需要多長時間？**
部署從 2026 年 4 月 6 日開始，將在幾週內完成。
**3. 如何知道更新已完成？**
您可以透過建立新儲存貯體並呼叫 [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html) API 操作來判斷 SSE-C 加密是否已停用，輕鬆判斷變更是否已在您的 AWS 區域中完成。更新完成後，所有新的一般用途儲存貯體都會預設停用 SSE-C 加密。您可以在建立 S3 儲存貯體之後，呼叫 [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作來調整這些設定。
**4. Amazon S3 是否會更新我現有的儲存貯體組態？**
如果 AWS 您的帳戶沒有任何 SSE-C 加密物件， AWS 會在您所有現有的儲存貯體上停用 SSE-C 加密。如果您 AWS 帳戶中的任何儲存貯體具有 SSE-C 加密物件， AWS 將不會變更該帳戶中任何儲存貯體上的儲存貯體組態。完成您 AWS 區域的`CreateBucket`變更後，新的預設設定將套用至所有新的一般用途儲存貯體。
**5. 更新完成之前，是否可以停用儲存貯體的 SSE-C 加密？**
是。您可以呼叫 [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) API 操作並指定新`BlockedEncryptionTypes`標頭，以停用任何儲存貯體的 SSE-C 加密。
**6. 我可以使用 SSE-C 來加密新儲存貯體中的資料嗎？**
是。Amazon S3 中的大多數現代使用案例都不再使用 SSE-C，因為它缺少伺服器端加密的靈活性是使用 Amazon S3 受管金鑰 (SSE-S3) 或使用 AWS KMS 金鑰 (SSE-KMS) 的伺服器端加密。如果您需要在新儲存貯體中使用 SSE-C 加密，您可以建立新的儲存貯體，然後在單獨的`PutBucketEncryption`請求中啟用 SSE-C 加密。
**範例**
```
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\]
}
}]
}'
```
**注意**
您必須擁有呼叫 `PutBucketEncryption` API 的`s3:PutEncryptionConfiguration`許可。
**7. 封鎖 SSE-C 如何影響對儲存貯體的請求？**
當儲存貯體的 SSE-C 遭到封鎖時，任何指定 SSE-C 加密的 `PutObject`、`CopyObject``PostObject`、 或 分段上傳或複寫請求都會遭到 HTTP 403 `AccessDenied`錯誤拒絕。
# 使用用戶端加密保護資料
*用戶端加密*是在本機加密的動作，以協助確保其在傳輸和靜態中的安全性。若要在將物件傳送到 Amazon S3 之前進行加密，請使用 Amazon S3 加密用戶端。當您的物件以這種方式加密時，您的物件不會公開給任何第三方，包括 AWS。Amazon S3 得知您的物件已經加密；Amazon S3 不負責加密或解密物件。您可以同時使用 Amazon S3 加密用戶端和[伺服器端加密](serv-side-encryption.md)來加密資料。將加密物件傳送到 Amazon S3 時，Amazon S3 只會偵測典型物件，無法將物件識別為已加密。
Amazon S3 加密用戶端可做為您與 Amazon S3 之間的媒介。執行個體化 Amazon S3 加密用戶端之後，物件會做為部分 Amazon S3 `PutObject` 和 `GetObject` 請求，自動加密和解密。您的物件皆使用不重複的資料金鑰來加密。即使您指定 KMS 金鑰做為包裝金鑰，Amazon S3 加密用戶端也不會使用儲存貯體金鑰或與其互動。
《Amazon S3 加密用戶端開發人員指南》**著重於 Amazon S3 加密用戶端的 3.0 版及更新版本。如需詳細資訊，請參閱《Amazon S3 加密用戶端開發人員指南》**中的[什麼是 Amazon S3 用戶端加密](https://docs.aws.amazon.com//amazon-s3-encryption-client/latest/developerguide/what-is-s3-encryption-client.html)。
如需 Amazon S3 加密用戶端舊版的詳細資訊，請參閱適用於您的程式設計語言的 AWS SDK 開發人員指南。
+ [適用於 Java 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-java/v1/developer-guide/examples-crypto.html)
+ [適用於 .NET 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-net/v3/developer-guide/kms-keys-s3-encryption.html)
+ [適用於 Go 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-go/v1/developer-guide/welcome.html)
+ [適用於 PHP 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-php/v3/developer-guide/s3-encryption-client.html)
+ [適用於 Ruby 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-ruby/v3/api/Aws/S3/Encryption.html)
+ [適用於 C\$1\$1 的 AWS SDK](https://docs.aws.amazon.com//sdk-for-cpp/v1/developer-guide/welcome.html)
# 使用加密保護傳輸中的資料
Amazon S3 支援資料傳輸的 HTTP 和 HTTPS 通訊協定。HTTP 以純文字傳輸資料，而 HTTPS 透過使用 Transport Layer Security (TLS) 加密資料來新增安全層。TLS 可防止竊聽、資料竄改和man-in-the-middle攻擊。接受 HTTP 流量時，大多數實作會使用 HTTPS 和 TLS 傳輸中的加密來保護用戶端和 Amazon S3 之間傳輸的資料。
## TLS 1.2 和 TLS 1.3 支援
針對所有 的所有 API 端點，Amazon S3 支援 HTTPS 連線的 TLS 1.2 和 TLS 1.3 AWS 區域。S3 會自動交涉用戶端軟體支援最強大的 TLS 保護，以及您存取的 S3 端點。目前的 AWS 工具 (2014 或更新版本），包括 AWS SDKs並 AWS CLI 自動預設為 TLS 1.3，您不需要採取任何動作。如果需要回溯相容於 TLS 1.2，您可以透過用戶端組態設定覆寫此自動交涉，以指定特定的 TLS 版本。使用 TLS 1.3 時，您可以選擇設定混合式後量子金鑰交換 (ML-KEM)，以向 Amazon S3 發出可保護量子的請求。如需詳細資訊，請參閱[為您的用戶端設定混合式後量子 TLS](pqtls-how-to.md)。
**注意**
所有 S3 端點都支援 TLS 1.3，但 Amazon S3 和多區域存取點 AWS PrivateLink 除外。
## 監控 TLS 用量
您可以使用 Amazon S3 伺服器存取日誌或 AWS CloudTrail 來監控對 Amazon S3 儲存貯體的請求。兩個記錄選項都會記錄每個請求中使用的 TLS 版本和密碼套件。
+ **Amazon S3 伺服器存取日誌** – 伺服器存取日誌提供對儲存貯體提出之請求的詳細記錄。舉例來說，存取記錄資訊在安全與存取稽核中相當實用。如需詳細資訊，請參閱[Amazon S3 伺服器存取日誌格式](LogFormat.md)。
+ **AWS CloudTrail** – [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) 是一種服務，可提供使用者、角色或服務所採取動作的記錄 AWS 。CloudTrail 會將 Amazon S3 的所有 API 呼叫當做事件來擷取。如需詳細資訊，請參閱[Amazon S3 CloudTrail 事件](cloudtrail-logging-s3-info.md)。
## 強制執行傳輸中的加密
強制執行傳輸到 Amazon S3 的資料加密是安全最佳實務。您可以透過各種政策機制，強制執行僅限 HTTPS 的通訊或使用特定 TLS 版本。其中包括 S3 儲存貯體 ([儲存貯體政策](bucket-policies.md))、[服務控制政策](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) (SCPs)、資源[控制政策 ](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_rcps.html)(RCPs) 和 [VPC 端點政策的 IAM 資源型政策](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html)。
### 用於強制執行傳輸中加密的儲存貯體政策範例
您可以使用 [S3 條件金鑰](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html#amazons3-policy-keys)`s3:TlsVersion`，根據用戶端使用的 TLS 版本來限制對 Amazon S3 儲存貯體的存取。如需詳細資訊，請參閱[範例 6：需要最低 TLS 版本](amazon-s3-policy-keys.md#example-object-tls-version)。
**Example 使用 `S3:TlsVersion`條件索引鍵強制執行 TLS 1.3 的儲存貯體政策**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "DenyInsecureConnections",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
],
"Condition": {
"NumericLessThan": {
"s3:TlsVersion": "1.3"
}
}
}
]
}
```
您可以在 S3 儲存貯體政策中使用`aws:SecureTransport`[全域條件金鑰](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html)，來檢查請求是否透過 HTTPS (TLS) 傳送。與先前的範例不同，此條件不會檢查特定 TLS 版本。如需詳細資訊，請參閱[限制僅 HTTPS 請求才能存取](example-bucket-policies.md#example-bucket-policies-use-case-HTTP-HTTPS-1)。
**Example 使用`aws:SecureTransport`全域條件金鑰強制執行 HTTPS 的儲存貯體政策**
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "RestrictToTLSRequestsOnly",
"Action": "s3:*",
"Effect": "Deny",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
],
"Condition": {
"Bool": {
"aws:SecureTransport": "false"
}
},
"Principal": "*"
}
]
}
```
**以金鑰和更多範例為基礎的範例政策**
您可以在一個政策的先前範例中使用這兩種類型的條件金鑰。如需詳細資訊和其他強制執行方法，請參閱 AWS Storage 部落格文章[使用 TLS1.2 或更新的 Amazon S3 強制執行傳輸中的加密。](https://aws.amazon.com/blogs/storage/enforcing-encryption-in-transit-with-tls1-2-or-higher-with-amazon-s3/)
# 搭配 Amazon S3 使用混合式後量子 TLS
Amazon S3 支援 TLS 網路加密通訊協定的混合式後量子金鑰交換選項。當您使用 TLS 1.3 向 Amazon S3 端點提出請求時，您可以使用此 TLS 選項。S3 支援用於 TLS 工作階段的傳統密碼套件會對金鑰交換機制進行暴力破解攻擊，與目前的技術並不相容。不過，如果密碼編譯相關的量子電腦在未來變得實際，則 TLS 金鑰交換機制中使用的傳統密碼套件將容易遭受這些攻擊。目前，產業在混合式後量子金鑰交換上保持一致，該交換結合了傳統和後量子元素，以確保您的 TLS 連線至少與傳統密碼套件一樣強大。Amazon S3 目前支援混合 PQ-TLS，符合業界標準IANA規格
如果您開發的應用程式依賴於透過 TLS 連線傳遞的資料的長期機密性，您應該考慮在大規模量子電腦可供使用之前遷移到量子後密碼編譯的計劃。作為共同責任模型的一部分，S3 會在我們的服務端點上啟用規定人數安全密碼編譯。當瀏覽器和應用程式在其端啟用 PQ-TLS 時，S3 將選擇最強大的組態來保護傳輸中的資料。
**支援的端點類型和 AWS 區域**
Amazon S3 的後量子 TLS 適用於所有 AWS 區域。如需每個端點的 S3 端點清單 AWS 區域，請參閱《》中的 [Amazon Simple Storage Service 端點和配額](https://docs.aws.amazon.com/general/latest/gr/s3.html)*Amazon Web Services 一般參考*。
**注意**
除了 Amazon S3 S3、多區域存取點和 S3 向量之外，所有 S3 AWS PrivateLink 端點都支援混合式後量子 TLS。
## 搭配 Amazon S3 使用混合式後量子 TLS
您必須設定向 Amazon S3 提出請求的用戶端，以支援混合式後量子 TLS。設定 HTTP 用戶端測試環境或生產環境時，請注意下列資訊：
**傳輸中加密**
混合式後量子 TLS 僅用於傳輸中的加密。這可在資料從用戶端傳輸到 S3 端點時保護您的資料。這項新支援預設結合 Amazon S3 的伺服器端加密，利用AES-256演算法為客戶提供傳輸中和靜態的抗量子加密。如需 Amazon S3 中伺服器端加密的詳細資訊，請參閱[使用伺服器端加密保護資料](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html)。
**支援的用戶端**
使用混合式後量子 TLS 需要使用支援此功能的用戶端。 AWS SDKs和工具具有不同語言和執行時間的密碼編譯功能和組態。若要進一步了解特定工具的後量子密碼編譯，請參閱[啟用混合後量子 TLS](https://docs.aws.amazon.com/payment-cryptography/latest/userguide/pqtls-details.html)。
**注意**
對 Amazon S3 請求的 PQ-TLS 金鑰交換詳細資訊不適用於 AWS CloudTrail 事件或 S3 伺服器存取日誌。
## 進一步了解後量子 TLS
如需使用混合式後量子 TLS 的詳細資訊，請參閱下列資源。
+ 若要了解 的後量子密碼編譯 AWS，包括部落格文章和研究論文的連結，請參閱 [的後量子密碼編譯 AWS](https://aws.amazon.com/security/post-quantum-cryptography/)。
+ 如需 s2n-tls 的資訊，請參閱 [全新開放原始碼 TLS 實作 s2n-tls 簡介](https://aws.amazon.com/blogs/security/introducing-s2n-a-new-open-source-tls-implementation/)和使用 [https://github.com/aws/s2n-tls/tree/main/docs/usage-guide](https://github.com/aws/s2n-tls/tree/main/docs/usage-guide)。
+ 如需有關 AWS 通用執行期 HTTP 用戶端的資訊，請參閱《 *AWS SDK for Java 2.x 開發人員指南*》中的[設定 AWS CRT 型 HTTP 用戶端](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/http-configuration-crt.html)。
+ 如需國家標準技術研究 (NIST) 的後量子加密法專案的資訊，請參閱[後量子加密法](https://csrc.nist.gov/Projects/Post-Quantum-Cryptography)。
+ 如需有關 NIST 後量子密碼編譯標準化的資訊，請參閱 [NIST 的後量子密碼編譯標準化](https://csrc.nist.gov/Projects/post-quantum-cryptography/post-quantum-cryptography-standardization)。
# 為您的用戶端設定混合式後量子 TLS
若要搭配 Amazon S3 使用 PQ-TLS，您需要將用戶端設定為支援後量子金鑰交換演算法。此外，請確定您的用戶端支援混合式方法，將傳統的橢圓曲線密碼編譯與 ML-KEM (Module-Lattice-Based金鑰封裝機制） 等量子後演算法結合。
特定組態取決於您的用戶端程式庫和程式設計語言。如需詳細資訊，請參閱[啟用混合式後量子 TLS](https://docs.aws.amazon.com/payment-cryptography/latest/userguide/pqtls-details.html)。
## Java 2 的用戶端組態範例： AWS SDK
在此程序中，為 AWS 通用執行期 HTTP 用戶端新增 Maven 相依性。接下來，設定偏好後量子 TLS 的 HTTP 用戶端。然後，建立使用 HTTP 用戶端的 Amazon S3 用戶端。
**注意**
已作為預覽版提供的 AWS 通用執行期 HTTP 用戶端，已於 2023 年 2 月正式推出。在該版本中，`tlsCipherPreference` 類別和 `tlsCipherPreference()` 方法參數由 `postQuantumTlsEnabled()` 方法參數取代。如果您在預覽期間使用此範例，則需要更新程式碼。
1. 將 AWS Common Runtime 用戶端新增至 Maven 相依性。我們建議使用最新的可用版本。
例如，此陳述式會將 `2.30.22`版本的 AWS Common Runtime 用戶端新增至您的 Maven 相依性。
```
software.amazon.awssdk
aws-crt-client
2.30.22
```
1. 若要啟用混合式後量子密碼套件，請將 AWS SDK for Java 2.x 新增至您的專案並初始化。然後如下列範例所示在 HTTP 用戶端啟用混合式後量子密碼套件。
此程式碼使用 `postQuantumTlsEnabled()`方法參數來設定[AWS 常用的執行時間 HTTP 用戶端](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/http-configuration-crt.html)，其偏好建議的混合式後量子密碼套件 ECDH 搭配 ML-KEM。然後，它會使用設定的 HTTP 用戶端來建置 Amazon S3 非同步用戶端的執行個體 [https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3AsyncClient.html)。此程式碼完成後，`S3AsyncClient`執行個體上的所有 [Amazon S3 API](https://docs.aws.amazon.com/AmazonS3/latest/API/) 請求都會使用混合式後量子 TLS。
**重要**
自 v2.35.11 起，發起人不再需要`.postQuantumTlsEnabled(true)`將 設定為為您的用戶端啟用混合式後量子 TLS。所有比 v2.35.11 更新的版本預設都會啟用後量子 TLS。
```
// Configure HTTP client
SdkAsyncHttpClient awsCrtHttpClient = AwsCrtAsyncHttpClient.builder()
.postQuantumTlsEnabled(true)
.build();
// Create the Amazon S3 async client
S3AsyncClient s3Async = S3AsyncClient.builder()
.httpClient(awsCrtHttpClient)
.build();
```
1. 使用混合式後量子 TLS 測試您的 Amazon S3 呼叫。
當您在設定的 Amazon S3 用戶端上呼叫 Amazon S3 API 操作時，您的呼叫會使用混合式後量子 TLS 傳輸至 Amazon S3 端點。若要測試您的組態，請呼叫 Amazon S3 API，例如 `[ListBuckets](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html)`。
```
ListBucketsResponse reponse = s3Async.listBuckets();
```
### 測試您的混合式後量子 TLS 組態
考慮在呼叫 Amazon S3 的應用程式上使用混合密碼套件執行下列測試。
+ 執行負載測試和基準測試。混合式密碼套件的執行方式不同於傳統的金鑰交換演算法。您可能需要調整連線逾時，以允許較長的交握時間。如果您在 AWS Lambda 函數內執行 ，請延長執行逾時設定。
+ 請嘗試從不同位置進行連線。視您請求佔用的網路路徑而定，您必須探索中繼主機、代理或採用深層封包檢查 (DPI) 的防火牆是否封鎖請求。這可能是因使用 TLS [ClientHello](https://tools.ietf.org/html/rfc5246#section-7.4.1.2) 部分中的新加密套件所導致，或因大型金要交換訊息所導致。如果您解決這些問題的能力有限，請與您的安全團隊或 IT 管理員合作，以更新相關組態並解除對於新 TLS 密碼套件的封鎖。