Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation du chiffrement côté serveur avec les clés fournies par le client (SSE-C)
Le chiffrement côté serveur consiste à protéger les données au repos. Un chiffrement côté serveur chiffre uniquement les données d’objet, pas les métadonnées d’objet. Vous pouvez utiliser le chiffrement côté serveur avec des clés fournies par le client (SSE-C) dans vos compartiments à usage général pour chiffrer vos données avec vos propres clés de chiffrement. Avec la clé de chiffrement que vous fournissez dans la demande, Amazon S3 gère le chiffrement des données quand il écrit sur les disques et le déchiffrement des données quand vous accédez à vos objets. Par conséquent, vous n’avez pas besoin de conserver de code pour procéder au chiffrement et déchiffrement des données. Il ne vous reste qu’à gérer les clés de chiffrement que vous fournissez.
La plupart des cas d'utilisation modernes d'Amazon S3 n'utilisent plus le SSE-C car il n'offre pas la flexibilité du chiffrement côté serveur avec des clés gérées Amazon S3 (SSE-S3) ou du chiffrement côté serveur avec des clés KMS (SSE-KMS). AWS L'obligation du SSE-C de fournir la clé de chiffrement chaque fois que vous interagissez avec vos données chiffrées SSE-C rend impossible le partage de votre clé SSE-C avec d'autres utilisateurs, rôles ou AWS services qui lisent les données de vos compartiments S3 afin d'opérer sur vos données. En raison de la prise en charge généralisée du SSE-KMS AWS, la plupart des charges de travail modernes n'utilisent pas le chiffrement SSE-C car il n'est pas aussi flexible que le SSE-KMS. Pour en savoir plus sur SSE-KMS, consultez. [Utilisation du chiffrement côté serveur à l'aide de AWS KMS clés (SSE-KMS)](UsingKMSEncryption.md)
Si vous souhaitez empêcher l'utilisation du chiffrement SSE-C pour les objets écrits dans votre bucket, vous pouvez bloquer le chiffrement SSE-C lorsque vous modifiez la configuration de chiffrement par défaut de votre bucket. Lorsque le SSE-C est bloqué pour un bucket à usage général `PutObject` `CopyObject``PostObject`, toute demande de téléchargement partitionné ou de réplication spécifiant le chiffrement SSE-C sera rejetée avec une erreur. `HTTP 403 AccessDenied` Pour en savoir plus sur le blocage du SSE-C, consultez. [Blocage ou déblocage du SSE-C pour un compartiment à usage général](blocking-unblocking-s3-c-encryption-gpb.md)
Aucuns frais supplémentaires ne s’appliquent à l’utilisation du chiffrement SSE-C. Toutefois, les demandes de configuration et d’utilisation du chiffrement SSE-C entraînent des frais de demande Amazon S3 standard. Pour obtenir des informations sur la tarification, consultez [Tarification Amazon S3](https://aws.amazon.com/s3/pricing/).
**Important**
Comme [annoncé le 19 novembre 2025,](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service déploie un nouveau paramètre de sécurité des compartiments par défaut qui désactive automatiquement le chiffrement côté serveur à l'aide de clés fournies par le client (SSE-C) pour tous les nouveaux compartiments à usage général. Pour les compartiments existants ne Comptes AWS contenant aucun objet chiffré SSE-C, Amazon S3 désactivera également le SSE-C pour toutes les nouvelles demandes d'écriture. Dans le cas Comptes AWS de l'utilisation du SSE-C, Amazon S3 ne modifiera la configuration de chiffrement des compartiments sur aucun des compartiments existants de ces comptes. Ce déploiement a débuté le 6 avril 2026 et s'achèvera au cours des prochaines semaines dans 37 AWS régions, dont la AWS Chine et AWS GovCloud les États-Unis.
Avec ces modifications, les applications nécessitant un chiffrement SSE-C doivent délibérément activer le SSE-C en utilisant l'opération d'[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API après avoir créé un nouveau compartiment. Pour plus d'informations sur cette modification, consultez[FAQ sur le paramètre SSE-C par défaut pour les nouveaux buckets](default-s3-c-encryption-setting-faq.md).
## Considérations à prendre en compte avant d'utiliser SSE-C
+ S3 ne stocke jamais la clé de chiffrement lorsque vous utilisez SSE-C. Vous devez fournir la clé de chiffrement chaque fois que vous souhaitez que quelqu'un télécharge vos données chiffrées SSE-C depuis S3.
+ Vous gérez un mappage pour savoir quelle clé de chiffrement a été utilisée pour chiffrer quel objet. Vous devez assurer le suivi pour savoir quelle clé de chiffrement a été fournie pour quel objet. Cela signifie également que si vous perdez la clé de chiffrement, vous perdez l'objet.
+ Etant donné que vous gérez les clés de chiffrement du côté client, vous gérez toute sauvegarde supplémentaire, comme la rotation des clés, du côté client.
+ Cette conception peut rendre difficile le partage de votre clé SSE-C avec d'autres utilisateurs, rôles ou AWS services que vous utilisez pour exploiter vos données. En raison de la prise en charge généralisée du SSE-KMS AWS, la plupart des charges de travail modernes n'utilisent pas le SSE-C car celui-ci n'est pas aussi flexible que le SSE-KMS. Pour en savoir plus sur le SSE-KMS, voir [Utilisation du chiffrement côté serveur avec des clés AWS KMS (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html).
+ Cela signifie que les objets chiffrés avec SSE-C ne peuvent pas être déchiffrés nativement par les services gérés. AWS
+ Vous devez utiliser le protocole HTTPS lorsque vous spécifiez les en-têtes SSE-C pour vos demandes.
+ Amazon S3 rejette toute demande faite via HTTP lors de l’utilisation du chiffrement SSE-C. Pour des raisons de sécurité, nous vous recommandons de considérer toute clé que vous envoyez par erreur via HTTP comme compromise. Écartez la clé et permutez comme il convient.
+ Si le contrôle de version de votre bucket est activé, chaque version d'objet que vous chargez peut avoir sa propre clé de chiffrement. Vous devez assurer le suivi pour savoir quelle clé de chiffrement a été utilisée pour quelle version d’objet.
+ Le SSE-C n'est pas pris en charge dans la console Amazon S3. Vous ne pouvez pas utiliser la console Amazon S3 pour télécharger un objet et spécifier le chiffrement SSE-C. Vous pouvez également utiliser la console pour mettre à jour (par exemple, modifier la classe de stockage ou ajouter des métadonnées) un objet existant stocké grâce aux clés SSE-C.
**Topics**
+ [Considérations à prendre en compte avant d'utiliser SSE-C](#considerations-before-using-sse-c)
+ [Spécification du chiffrement côté serveur avec des clés fournies par le client (SSE-C)](specifying-s3-c-encryption.md)
+ [Blocage ou déblocage du SSE-C pour un compartiment à usage général](blocking-unblocking-s3-c-encryption-gpb.md)
+ [FAQ sur le paramètre SSE-C par défaut pour les nouveaux buckets](default-s3-c-encryption-setting-faq.md)
# Spécification du chiffrement côté serveur avec des clés fournies par le client (SSE-C)
Pour utiliser le chiffrement côté serveur avec des clés fournies par le client (SSE-C), assurez-vous d'abord que le SSE-C n'est pas un type de chiffrement bloqué dans la configuration de chiffrement par défaut de votre compartiment à usage général Amazon S3. En cas de blocage, vous pouvez activer ce type de chiffrement en mettant à jour votre configuration de chiffrement par défaut pour le compartiment. Ensuite, vous pouvez utiliser SSE-C dans vos demandes de téléchargement en transmettant les en-têtes requis. Voir[Actions Amazon S3 prenant en charge l'écriture de données avec SSE-C](#amazon-s3-actions-that-support-writing-data-with-sse-c), et assurez-vous d'inclure le[En-têtes d'API S3 requis pour les demandes de chiffrement et de déchiffrement d'objets SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests).
Lorsque vous chargez un objet spécifiant SSE-C, Amazon S3 utilise la clé de chiffrement que vous fournissez pour appliquer le chiffrement AES-256 à vos données. Amazon S3 supprime ensuite la clé de chiffrement de la mémoire. Lorsque vous récupérez un objet, vous devez fournir la même clé de chiffrement dans la demande. Amazon S3 vérifie tout d’abord que la clé de chiffrement que vous avez fournie correspond, puis il déchiffre l’objet avant de vous renvoyer les données de ce dernier.
Avant d'utiliser SSE-C, assurez-vous d'avoir pris connaissance du. [Considérations à prendre en compte avant d'utiliser SSE-C](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c)
**Note**
Amazon S3 ne stocke pas la clé de chiffrement que vous fournissez. À la place, il stocke un code d’authentification de message utilisant hash (HMAC) crypté de manière aléatoire de la clé de chiffrement pour valider les demandes futures. La valeur HMAC cryptée ne peut pas être utilisée pour retrouver la valeur de la clé de chiffrement ou pour déchiffrer les contenus de l’objet chiffré. Cela signifie que si vous perdez la clé de chiffrement, vous perdez l’objet.
**Topics**
+ [Actions SSE-C et en-têtes requis](#sse-c-actions-and-required-headers)
+ [Exemple de politique de compartiment pour appliquer le chiffrement SSE-C](#example-bucket-policy-to-enforce-sse-c-encryption)
+ [Présigné URLs et SSE-C](#ssec-and-presignedurl)
+ [Faire des demandes avec SSE-C](#making-requests-with-sse-c)
+ [Utilisation de l'API REST](#using-rest-api-sse-c)
+ [Utilisation du AWS SDKs pour spécifier le SSE-C pour les opérations PUT, GET, Head et Copy](#sse-c-using-sdks)
+ [Utilisation du AWS SDKs pour spécifier le SSE-C pour les téléchargements partitionnés](#sse-c-using-sdks-multipart-uploads)
## Actions SSE-C et en-têtes requis
La spécification de SSE-C sur le S3 pris en charge APIs nécessite de transmettre des paramètres de demande spécifiques.
**Note**
L'`PutBucketEncryption`API d'Amazon S3 est utilisée pour configurer le chiffrement côté serveur par défaut pour un compartiment. Toutefois, `PutBucketEncryption` ne prend pas en charge l'activation de SSE-C comme méthode de chiffrement par défaut pour un bucket. Le SSE-C est une méthode de chiffrement au niveau de l'objet dans laquelle vous fournissez la clé de chiffrement à Amazon S3 à chaque demande de chargement ou de téléchargement d'objet. Amazon S3 utilise cette clé pour chiffrer ou déchiffrer l'objet lors de la demande, puis supprime la clé. Cela signifie que SSE-C est activé pour chaque objet, et non comme paramètre de compartiment par défaut.
### Actions Amazon S3 prenant en charge l'écriture de données avec SSE-C
Vous pouvez demander un chiffrement côté serveur avec des clés fournies par le client (SSE-C) lorsque vous écrivez des objets dans un bucket à usage général en utilisant les opérations ou actions d'API suivantes :
+ [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)
**Note**
S3 Replication prend en charge les objets chiffrés avec le SSE-C. Pour plus d’informations sur la réplication des objets chiffrés, consultez [Réplication d’objets chiffrés (SSE-S3, SSE-KMS, DSSE-KMS, SSE-C)](replication-config-for-kms-objects.md).
### En-têtes d'API S3 requis pour les demandes de chiffrement et de déchiffrement d'objets SSE-C
Vous devez fournir les trois en-têtes d'API suivants pour chiffrer ou déchiffrer des objets avec SSE-C :
+ `x-amz-server-side-encryption-customer-algorithm`Utilisez cet en-tête pour spécifier l'algorithme de chiffrement. La valeur de l’en-tête doit être AES256.
+ `x-amz-server-side-encryption-customer-key`Utilisez cet en-tête pour fournir la clé de chiffrement 256 bits codée en base64 qu'Amazon S3 utilisera pour chiffrer ou déchiffrer vos données.
+ `x-amz-server-side-encryption-customer-key-MD5`Utilisez cet en-tête pour fournir le MD5 résumé de 128 bits codé en base64 de la clé de chiffrement conformément à la RFC 1321. Amazon S3 utilise cet en-tête pour vérifier l’intégrité du message et veiller à ce que la clé de chiffrement ait été transmise sans erreur.
### En-têtes d'API S3 requis pour les demandes de copie d'objets source chiffrés avec SSE-C
Vous devez fournir les trois en-têtes d'API suivants pour copier les objets source chiffrés avec SSE-C :
+ `x-amz-copy-source-server-side-encryption-customer-algorithm`Incluez cet en-tête pour spécifier l'algorithme qu'Amazon S3 doit utiliser pour déchiffrer l'objet source. La valeur doit être AES256.
+ `x-amz-copy-source-server-side-encryption-customer-key`Incluez cet en-tête pour fournir la clé de chiffrement codée en base64 qu'Amazon S3 utilisera pour déchiffrer l'objet source. La clé de chiffrement doit être celle fournie à Amazon S3 lorsque vous avez créé l’objet source. Sinon, Amazon S3 ne peut pas déchiffrer l’objet.
+ `x-amz-copy-source-server-side-encryption-customer-key-MD5`Incluez cet en-tête pour fournir le MD5 résumé de 128 bits codé en base64 de la clé de chiffrement conformément à la RFC 1321.
## Exemple de politique de compartiment pour appliquer le chiffrement SSE-C
Pour exiger le SSE-C pour tous les objets écrits dans un compartiment Amazon S3, vous pouvez utiliser une politique de compartiment. Par exemple, la stratégie de compartiment suivante refuse les autorisations de chargement d’objet (`s3:PutObject`) autorisations pour toutes les demandes qui n’incluent pas l’en-tête `x-amz-server-side-encryption-customer-algorithm` demandant SSE-C.
```
{
"Version":"2012-10-17",
"Id": "PutObjectPolicy",
"Statement": [
{
"Sid": "RequireSSECObjectUploads",
"Effect": "Deny",
"Principal": "*",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Condition": {
"Null": {
"s3:x-amz-server-side-encryption-customer-algorithm": "true"
}
}
}
]
}
```
**Important**
Si vous utilisez une politique de compartiment pour activer SSE-C`s3:PutObject`, vous devez inclure l'`x-amz-server-side-encryption-customer-algorithm`en-tête dans toutes les demandes de téléchargement partitionné (CreateMultipartUpload UploadPart, et). CompleteMultipartUpload
## Présigné URLs et SSE-C
Vous pouvez générer une URL présignée qui peut être utilisée pour des opérations comme le chargement d’un nouvel objet, la récupération d’un objet existant ou la récupération des métadonnées d’objet. URLsSupporte le SSE-C présigné comme suit :
+ Lors de la création d’une URL présignée, vous devez spécifier l’algorithme en utilisant l’en-tête `x-amz-server-side-encryption-customer-algorithm` dans le calcul de la signature.
+ Lorsque vous utilisez l’URL présignée pour charger un nouvel objet, récupérer un objet existant ou récupérer uniquement des métadonnées d’objet, vous devez fournir tous les en-têtes de chiffrement dans la demande de votre application cliente.
**Note**
Pour les non-SSE-C objets, vous pouvez générer une URL présignée et la coller directement dans un navigateur pour accéder aux données.
Toutefois, vous ne pouvez pas procéder ainsi pour des objets SSE-C, car en plus de l’URL présignée, vous devez également inclure des en-têtes HTTP spécifiques aux objets SSE-C. Par conséquent, vous ne pouvez utiliser le présigné URLs pour les objets SSE-C que par programmation.
Pour plus d'informations sur le présigné URLs, consultez[Téléchargez et chargez des objets avec une signature préalable URLs](using-presigned-url.md).
## Faire des demandes avec SSE-C
Au moment de la création de l’objet avec l’API REST, vous pouvez spécifier un chiffrement côté serveur avec les clés fournies par le client (SSE-C). Lorsque vous utilisez SSE-C, vous devez fournir les informations de clé de chiffrement à l'aide du. [En-têtes d'API S3 requis pour les demandes de copie d'objets source chiffrés avec SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c) Vous pouvez utiliser les bibliothèques d'encapsulation du AWS SDK pour ajouter ces en-têtes à votre demande. Si nécessaire, vous pouvez effectuer les appels à l’API REST Amazon S3 directement dans l’application.
**Important**
Avant de spécifier le chiffrement côté serveur avec des clés fournies par le client (SSE-C), assurez-vous que le chiffrement SSE-C n'est pas bloqué pour votre compartiment à usage général. Pour de plus amples informations, veuillez consulter [Blocage ou déblocage du SSE-C pour un compartiment à usage général](blocking-unblocking-s3-c-encryption-gpb.md).
**Note**
Vous ne pouvez pas utiliser la console Amazon S3 pour télécharger un objet et demander le SSE-C. Vous ne pouvez pas non plus utiliser la console pour mettre à jour (par exemple, modifier la classe de stockage ou ajouter des métadonnées) un objet existant stocké à l'aide de SSE-C. Pour plus d'informations, consultez[En-têtes d'API S3 requis pour les demandes de chiffrement et de déchiffrement d'objets SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests).
## Utilisation de l'API REST
### Amazon S3 REST APIs compatible SSE-C
Les Amazon S3 suivants prennent en APIs charge le chiffrement côté serveur à l'aide de clés de chiffrement fournies par le client (SSE-C).
+ **Opération GET** – Lorsque vous récupérez des objets via l’API GET (consultez [GET Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)), vous pouvez spécifier ces en-têtes de demande.
+ **Opération HEAD** – Pour récupérer les métadonnées d’objet via l’API HEAD (consultez [Head Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)), vous pouvez spécifier ces en-têtes de demande.
+ **Opération PUT** – Lorsque vous chargez des données via l’API PutObject (consultez [PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)), vous pouvez spécifier ces en-têtes de demande.
+ **Chargement partitionné** – Lorsque vous chargez des objets volumineux via l’API de chargement partitionné, vous pouvez spécifier ces en-têtes. Vous spécifiez ces en-têtes dans la demande d'initiation (voir [Initiate multipart Upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)) et dans chaque demande de téléchargement partiel suivante (voir [Upload Part](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html) or [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)). Pour chaque demande de chargement d’une partie, les informations de chiffrement doivent être les mêmes que celles fournies dans la demande de lancement du chargement partitionné.
+ **Opération POST** – Lorsque vous utilisez une opération POST pour charger un objet (consultez [POST Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)), à la place des en-têtes de demande, fournissez les mêmes informations dans les champs du formulaire.
+ **Opération de copie** — Lorsque vous copiez un objet (voir [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)), vous disposez à la fois d'un objet source et d'un objet cible :
+ Si vous souhaitez spécifier le type de chiffrement de l'objet cible, vous devez fournir l'en-tête de `x-amz-server-side-encryption ` demande.
+ Si vous souhaitez que l'objet cible soit chiffré à l'aide de SSE-C, vous devez fournir des informations de chiffrement à l'aide de l'API S3. [En-têtes d'API S3 requis pour les demandes de chiffrement et de déchiffrement d'objets SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests)
+ Si l'objet source est chiffré à l'aide du protocole SSE-C, vous devez fournir les informations de clé de chiffrement à l'aide des en-têtes de l'API S3. [En-têtes d'API S3 requis pour les demandes de copie d'objets source chiffrés avec SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c)
## Utilisation du AWS SDKs pour spécifier le SSE-C pour les opérations PUT, GET, Head et Copy
Les exemples suivants illustrent la demande d’un chiffrement côté serveur avec les clés de chiffrement fournies par le client (SSE-C) pour les objets. Les exemples exécutent les opérations suivantes. Chaque opération montre comment spécifier SSE-C-related les en-têtes dans la demande :
+ **Put object** – Charge un objet et demande un chiffrement côté serveur avec une clé de chiffrement fournie par le client.
+ **Get object** – Télécharge l’objet chargé à l’étape précédente. Dans la demande, vous fournissez les mêmes informations de chiffrement que celles fournies lors du chargement de l’objet. Amazon S3 a besoin de ces informations pour déchiffrer l’objet afin de pouvoir vous le renvoyer.
+ **Get object metadata** – Récupère les métadonnées de l’objet. Vous fournissez les mêmes informations de chiffrement que celles utilisées quand l’objet a été chargé.
+ **Copy object** – Effectue une copie de l’objet précédemment chargé. Comme l’objet source est stocké via SSE-C, vous devez fournir ses informations de chiffrement dans votre demande de copie. Par défaut, Amazon S3 ne chiffre la copie de l’objet que si vous le demandez explicitement. Cet exemple demande à Amazon S3 de stocker une copie chiffrée de l’objet.
------
#### [ Java ]
**Note**
Cet exemple montre comment copier un objet en une seule opération. Lorsque vous utilisez l’API de chargement partitionné pour charger des objets volumineux, vous fournissez les informations de chiffrement comme illustré dans l’exemple suivant. Pour des exemples de téléchargements partitionnés utilisant le AWS SDK pour Java, voir. [Chargement d’un objet à l’aide du chargement partitionné](mpu-upload-object.md)
Pour ajouter les informations de chiffrement requises, vous incluez une clé `SSECustomerKey` dans votre demande. Pour plus d’informations sur la classe `SSECustomerKey`, consultez la section API REST.
Pour obtenir des instructions sur la création et le test d'un échantillon fonctionnel, voir [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) dans le guide du AWS SDK pour Java développeur.
**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 ]
**Note**
Pour obtenir des exemples de chargement d’objets volumineux à l’aide de l’API de chargement partitionné, consultez [Chargement d’un objet à l’aide du chargement partitionné](mpu-upload-object.md) et [Utilisation de AWS SDKs (API de bas niveau)](mpu-upload-object.md#mpu-upload-low-level).
Pour plus d'informations sur la configuration et l'exécution des exemples de code, consultez [Getting Started with the AWS SDK for](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) .NET dans *AWS le Guide du développeur du SDK pour* .NET.
**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);
}
}
}
```
------
## Utilisation du AWS SDKs pour spécifier le SSE-C pour les téléchargements partitionnés
L’exemple de la section précédente montre comment demander le chiffrement côté serveur à l’aide d’une clé de chiffrement fournie par le client (SSE-C) dans les opérations PUT, GET, Head et Copy. Cette section décrit les autres Amazon S3 APIs qui prennent en charge le SSE-C.
------
#### [ Java ]
Pour télécharger des objets de grande taille, vous pouvez utiliser le téléchargement APIs partitionné. Pour de plus amples informations, veuillez consulter [Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md). Vous pouvez utiliser le haut niveau ou le bas niveau APIs pour télécharger des objets volumineux. Ils APIs prennent en charge les en-têtes liés au chiffrement dans la demande.
+ Lorsque vous utilisez l'`TransferManager`API de haut niveau, vous fournissez les en-têtes spécifiques au chiffrement dans le. `PutObjectRequest` Pour de plus amples informations, veuillez consulter [Chargement d’un objet à l’aide du chargement partitionné](mpu-upload-object.md).
+ Lorsque vous utilisez l’API de bas niveau, vous fournissez les informations de chiffrement dans l’objet `InitiateMultipartUploadRequest`, suivies des mêmes informations dans chaque `UploadPartRequest`. Il est inutile de fournir des en-têtes liés au chiffrement dans votre objet `CompleteMultipartUploadRequest`. Pour obtenir des exemples, consultez [Utilisation de AWS SDKs (API de bas niveau)](mpu-upload-object.md#mpu-upload-low-level).
L’exemple ci-dessous utilise `TransferManager` pour créer des objets ; il explique également la marche à suivre pour fournir des informations SSE-C. Cet exemple effectue les opérations suivantes :
+ Crée un objet à l’aide de la méthode `TransferManager.upload()`. Dans l'`PutObjectRequest`instance, vous fournissez des informations de clé de chiffrement dans la demande. Amazon S3 chiffre l’objet en utilisant la clé fournie par le client.
+ Effectue une copie de l’objet en appelant la méthode `TransferManager.copy()`. L’exemple demande à Amazon S3 de chiffrer la copie de l’objet à l’aide d’un nouvel objet `SSECustomerKey`. L’objet source étant chiffré au moyen de SSE-C, `CopyObjectRequest`fournit également la clé de chiffrement de l’objet source, afin qu’Amazon S3 puisse déchiffrer l’objet avant de le copier.
**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 ]
Pour télécharger des objets volumineux, vous pouvez utiliser l'API de téléchargement partitionné (voir[Chargement et copie d’objets à l’aide du chargement partitionné dans Amazon S3](mpuoverview.md)). AWS Le SDK pour .NET fournit des fonctionnalités de haut niveau ou de APIs bas niveau pour le téléchargement d'objets volumineux. Ils APIs prennent en charge les en-têtes liés au chiffrement dans la demande.
+ Lorsque vous utilisez l’API de haut niveau `Transfer-Utility `, vous fournissez les en-têtes propres au chiffrement dans l’objet `TransferUtilityUploadRequest` comme illustré. Pour des exemples de code, consultez [Chargement d’un objet à l’aide du chargement partitionné](mpu-upload-object.md).
```
TransferUtilityUploadRequest request = new TransferUtilityUploadRequest()
{
FilePath = filePath,
BucketName = existingBucketName,
Key = keyName,
// Provide encryption information.
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
};
```
+ Lorsque vous utilisez l’API de bas niveau, vous fournissez des informations de chiffrement dans votre demande de lancement du chargement partitionné. Ces informations de chiffrement doivent être identiques dans les demandes de chargement partitionné qui suivent. Il est toutefois inutile de fournir des en-têtes liés au chiffrement dans votre demande de fin de chargement partitionné. Pour obtenir des exemples, consultez [Utilisation de AWS SDKs (API de bas niveau)](mpu-upload-object.md#mpu-upload-low-level).
L’exemple suivant concerne un chargement partitionné de niveau inférieur exécutant une copie d’un objet volumineux existant. Dans cet exemple, l’objet à copier est stocké dans Amazon S3 à l’aide d’une clé SSE-C, et vous souhaitez également enregistrer l’objet cible à l’aide d’une clé SSE-C. Dans l’exemple, vous procédez comme suit :
+ Initier une demande de chargement partitionné en fournissant une clé de chiffrement et les informations connexes.
+ Fournir les clés de chiffrement de l’objet source et cible et les informations relatives dans la `CopyPartRequest`.
+ Obtenir la taille de l’objet source à copier en récupérant les métadonnées de l’objet.
+ Charger les objets par lots de 5 Mo.
**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);
}
}
}
}
```
------
# Blocage ou déblocage du SSE-C pour un compartiment à usage général
La plupart des cas d'utilisation modernes d'Amazon S3 n'utilisent plus le chiffrement côté serveur avec des clés fournies par le client (SSE-C) car il n'est pas aussi flexible que le chiffrement côté serveur avec les clés gérées par Amazon S3 (SSE-S3) ou le chiffrement côté serveur avec des clés KMS (SSE-KMS). AWS L'obligation du SSE-C de fournir la clé de chiffrement chaque fois que vous interagissez avec vos données chiffrées SSE-C rend impossible le partage de votre clé SSE-C avec d'autres utilisateurs, rôles ou AWS services qui lisent les données de vos compartiments S3 afin d'opérer sur vos données.
Pour limiter les types de chiffrement côté serveur que vous pouvez utiliser dans vos compartiments à usage général, vous pouvez choisir de bloquer les demandes d'écriture SSE-C en mettant à jour votre configuration de chiffrement par défaut pour vos compartiments. Cette configuration au niveau du compartiment bloque les demandes de téléchargement d'objets qui spécifient SSE-C. Lorsque le SSE-C est bloqué pour un bucket `PutObject` `CopyObject``PostObject`, toute demande de téléchargement ou de réplication partitionné ou multipartie spécifiant le chiffrement SSE-C sera rejetée avec une erreur HTTP 403. `AccessDenied`
Ce paramètre est un paramètre de l'`PutBucketEncryption`API et peut également être mis à jour à l'aide de la console S3, de la AWS CLI et AWS SDKs, si vous en avez l'`s3:PutEncryptionConfiguration`autorisation.
Les valeurs valides sont les `SSE-C` suivantes : ce qui bloque le chiffrement SSE-C pour le compartiment à usage général et `NONE` qui autorise l'utilisation du SSE-C pour les écritures dans le compartiment.
**Important**
Comme [annoncé le 19 novembre 2025,](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service déploie un nouveau paramètre de sécurité des compartiments par défaut qui désactive automatiquement le chiffrement côté serveur à l'aide de clés fournies par le client (SSE-C) pour tous les nouveaux compartiments à usage général. Pour les compartiments existants ne Comptes AWS contenant aucun objet chiffré SSE-C, Amazon S3 désactivera également le SSE-C pour toutes les nouvelles demandes d'écriture. Dans le cas Comptes AWS de l'utilisation du SSE-C, Amazon S3 ne modifiera la configuration de chiffrement des compartiments sur aucun des compartiments existants de ces comptes. Ce déploiement a débuté le 6 avril 2026 et s'achèvera au cours des prochaines semaines dans 37 AWS régions, dont la AWS Chine et AWS GovCloud les États-Unis.
Avec ces modifications, les applications nécessitant un chiffrement SSE-C doivent délibérément activer le SSE-C en utilisant l'opération d'[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API après avoir créé un nouveau compartiment. Pour plus d'informations sur cette modification, consultez[FAQ sur le paramètre SSE-C par défaut pour les nouveaux buckets](default-s3-c-encryption-setting-faq.md).
## Permissions
Utilisez l'`PutBucketEncryption`API AWS SDKs, la console S3 ou la AWS CLI pour bloquer ou débloquer les types de chiffrement pour un compartiment à usage général. Vous devez disposer des autorisations suivantes :
+ `s3:PutEncryptionConfiguration`
Utilisez l'`GetBucketEncryption`API AWS SDKs, la console S3 ou la AWS CLI pour afficher les types de chiffrement bloqués pour un compartiment à usage général. Vous devez disposer des autorisations suivantes :
+ `s3:GetEncryptionConfiguration`
## Considérations à prendre en compte avant de bloquer le chiffrement SSE-C
Une fois que vous avez bloqué SSE-C pour un compartiment, le comportement de chiffrement suivant s'applique :
+ Aucune modification n'a été apportée au chiffrement des objets présents dans le compartiment avant que vous ne bloquiez le chiffrement SSE-C.
+ Après avoir bloqué le chiffrement SSE-C, vous pouvez continuer à faire des HeadObject demandes sur GetObject des objets préexistants chiffrés avec SSE-C à condition de fournir les en-têtes SSE-C requis sur les demandes.
+ Lorsque le SSE-C est bloqué pour un bucket `PutObject` `CopyObject``PostObject`, toutes les demandes de téléchargement partitionné ou partitionné spécifiant le chiffrement SSE-C seront rejetées avec une erreur HTTP 403. `AccessDenied`
+ Si le SSE-C d'un compartiment de destination pour la réplication est bloqué et que les objets source répliqués sont chiffrés avec SSE-C, la réplication échouera avec une erreur HTTP 403. `AccessDenied`
Si vous souhaitez vérifier si vous utilisez le chiffrement SSE-C dans l'un de vos compartiments avant de bloquer ce type de cryptage, vous pouvez utiliser des outils tels que le contrôle de l'accès [AWS CloudTrail](https://aws.amazon.com/cloudtrail/)à vos données. Ce billet de [blog](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/) explique comment auditer les méthodes de chiffrement pour le téléchargement d'objets en temps réel. Vous pouvez également consulter cet [article de Re:Post](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets) pour vous guider dans l'interrogation des rapports d'inventaire S3 afin de voir si vous possédez des objets chiffrés SSE-C.
### Étapes
Vous pouvez bloquer ou débloquer le chiffrement côté serveur à l'aide de clés fournies par le client (SSE-C) pour un compartiment à usage général en utilisant la console Amazon S3, le () AWS Command Line Interface ,AWS CLI l'API REST Amazon S3 et. AWS SDKs
### Utilisation de la console S3
Pour bloquer ou débloquer le chiffrement SSE-C d'un compartiment à l'aide de la console Amazon S3 :
1. Connectez-vous à la console AWS de gestion et ouvrez la console Amazon S3 à l'adresse https://console.aws.amazon.com/s3/.
1. Dans le volet de navigation de gauche, choisissez des **buckets à usage général**.
1. Sélectionnez le compartiment pour lequel vous souhaitez bloquer le chiffrement SSE-C.
1. Sélectionnez l'onglet **Propriétés** du compartiment.
1. Accédez au panneau des propriétés de **chiffrement par défaut** du compartiment et sélectionnez **Modifier**.
1. Dans la section **Types de chiffrement bloqués**, cochez la case à côté du **chiffrement côté serveur avec des clés fournies par le client (SSE-C) pour bloquer le chiffrement SSE-C ou** décochez cette case pour autoriser le SSE-C.
1. Sélectionnez **Enregistrer les modifications**.
### À l'aide du AWS CLI
Pour installer la AWS CLI, reportez-vous à la section [Installation de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dans le *guide de AWS Command Line Interface l'utilisateur*.
L'exemple de CLI suivant vous montre comment bloquer ou débloquer le chiffrement SSE-C pour un bucket à usage général à l'aide du. AWS CLI Pour utiliser la commande, remplacez les *user input placeholders* par vos propres informations.
**Demande de blocage du chiffrement SSE-C pour un bucket à usage général :**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "SSE-C"
}
}]
}'
```
**Demande pour activer l'utilisation du chiffrement SSE-C sur un bucket à usage général :**
```
aws s3api put-bucket-encryption \
--bucket amzn-s3-demo-bucket \
--server-side-encryption-configuration '{
"Rules": [{
"BlockEncryptionTypes": {
"EncryptionType": "NONE"
}
}]
}'
```
## En utilisant le AWS SDKs
------
#### [ SDK for Java 2.x ]
Les exemples suivants vous montrent comment bloquer ou débloquer les écritures de chiffrement SSE-C dans vos compartiments à usage général à l'aide du AWS SDKs
**Exemple : PutBucketEncryption demande définissant la configuration de chiffrement par défaut sur SSE-S3 et bloquant le 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)));
```
**Exemple : PutBucketEncryption demande définissant la configuration de chiffrement par défaut sur SSE-S3 et débloquant 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 ]
**Exemple : PutBucketEncryption demande définissant la configuration de chiffrement par défaut sur SSE-S3 et bloquant le SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["SSE-C"]
}
}]
}
)
```
**Exemple : PutBucketEncryption demande définissant la configuration de chiffrement par défaut sur SSE-S3 et débloquant SSE-C**
```
s3 = boto3.client("s3")
s3.put_bucket_encryption(
Bucket="amzn-s3-demo-bucket",
ServerSideEncryptionConfiguration={
"Rules":[{
"ApplyServerSideEncryptionByDefault": {
"SSEAlgorithm": "AES256"
},
"BlockedEncryptionTypes": {
"EncryptionType": ["NONE"]
}
}]
}
)
```
------
## Utilisation de l'API REST
Pour plus d'informations sur la prise en charge par l'API REST d'Amazon S3 pour le blocage ou le déblocage du chiffrement SSE-C pour un compartiment à usage général, consultez la section suivante du manuel *Amazon Simple Storage* Service API Reference :
+ [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html)type de données utilisé dans le type de [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html)données des opérations [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)et de [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)l'API.
# FAQ sur le paramètre SSE-C par défaut pour les nouveaux buckets
**Important**
Comme [annoncé le 19 novembre 2025,](https://aws.amazon.com/blogs/storage/advanced-notice-amazon-s3-to-disable-the-use-of-sse-c-encryption-by-default-for-all-new-buckets-and-select-existing-buckets-in-april-2026/) Amazon Simple Storage Service déploie un nouveau paramètre de sécurité des compartiments par défaut qui désactive automatiquement le chiffrement côté serveur à l'aide de clés fournies par le client (SSE-C) pour tous les nouveaux compartiments à usage général. Pour les compartiments existants ne Comptes AWS contenant aucun objet chiffré SSE-C, Amazon S3 désactivera également le SSE-C pour toutes les nouvelles demandes d'écriture. Dans le cas Comptes AWS de l'utilisation du SSE-C, Amazon S3 ne modifiera la configuration de chiffrement des compartiments sur aucun des compartiments existants de ces comptes. Ce déploiement a débuté le 6 avril 2026 et s'achèvera au cours des prochaines semaines dans 37 AWS régions, dont la AWS Chine et AWS GovCloud les États-Unis.
Avec ces modifications, les applications nécessitant un chiffrement SSE-C doivent délibérément activer le SSE-C en utilisant l'opération d'[https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API après avoir créé un nouveau compartiment.
Les sections suivantes répondent aux questions concernant cette mise à jour.
**1. En avril 2026, le nouveau paramètre SSE-C entrera-t-il en vigueur pour tous les buckets nouvellement créés ?**
Oui. Ce déploiement a débuté le 6 avril 2026 et s'achèvera au cours des prochaines semaines dans 37 AWS régions, dont la AWS Chine et AWS GovCloud les États-Unis.
**Note**
Une fois le déploiement terminé, les compartiments nouvellement créés dans toutes les AWS régions, à l'exception du Moyen-Orient (Bahreïn) et du Moyen-Orient (Émirats arabes unis), SSE-C seront désactivés par défaut.
**2. Combien de temps faudra-t-il avant que ce déploiement ne couvre toutes les AWS régions ?**
Le déploiement a débuté le 6 avril 2026 et se terminera dans quelques semaines.
**3. Comment saurai-je que la mise à jour est terminée ?**
Vous pouvez facilement déterminer si la modification est terminée dans votre AWS région en créant un nouveau compartiment et en appelant l'opération [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html)API pour déterminer si le chiffrement SSE-C est désactivé. Une fois la mise à jour terminée, le chiffrement SSE-C sera automatiquement désactivé par défaut pour tous les nouveaux compartiments à usage général. Vous pouvez ajuster ces paramètres après avoir créé votre compartiment S3 en appelant l'opération [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API.
**4. Amazon S3 mettra-t-il à jour mes configurations de compartiment existantes ?**
Si votre AWS compte ne contient aucun objet chiffré SSE-C, le chiffrement SSE-C AWS sera désactivé sur tous vos buckets existants. Si l'un des compartiments de votre AWS compte contient des objets chiffrés SSE-C, la configuration des compartiments de ce compte ne AWS sera modifiée. Une fois le `CreateBucket` changement effectué pour votre AWS région, le nouveau paramètre par défaut s'appliquera à tous les nouveaux compartiments à usage général.
**5. Puis-je désactiver le chiffrement SSE-C pour mes compartiments avant la fin de la mise à jour ?**
Oui. Vous pouvez désactiver le chiffrement SSE-C pour n'importe quel compartiment en appelant l'opération [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)API et en spécifiant le nouvel `BlockedEncryptionTypes` en-tête.
**6. Puis-je utiliser le SSE-C pour chiffrer les données de mes nouveaux compartiments ?**
Oui. La plupart des cas d'utilisation modernes d'Amazon S3 n'utilisent plus le SSE-C car il n'est pas aussi flexible que le chiffrement côté serveur avec les clés gérées par Amazon S3 (SSE-S3) ou le chiffrement côté serveur avec des clés KMS (SSE-KMS). AWS Si vous devez utiliser le chiffrement SSE-C dans un nouveau compartiment, vous pouvez créer le nouveau compartiment, puis activer l'utilisation du chiffrement SSE-C dans une demande distincte. `PutBucketEncryption`
**Exemple**
```
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\]
}
}]
}'
```
**Note**
Vous devez être `s3:PutEncryptionConfiguration` autorisé à appeler l'`PutBucketEncryption`API.
**7. Comment le blocage du SSE-C affecte-t-il les demandes adressées à mon bucket ?**
Lorsque le SSE-C est bloqué pour un bucket `PutObject` `CopyObject``PostObject`, toute demande de téléchargement ou de réplication partitionné ou multipartie spécifiant le chiffrement SSE-C sera rejetée avec une erreur HTTP 403. `AccessDenied`