# Como usar criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) A criptografia de servidor envolve a proteção de dados em repouso. A criptografia no lado do servidor criptografa somente os dados de objeto, não os metadados de objeto. É possível usar a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) em buckets de uso geral para criptografar seus dados com suas próprias chaves de criptografia. Com a chave de criptografia que você fornece como parte de sua solicitação, o Amazon S3 gerencia a criptografia de dados ao gravar em discos, e a descriptografia dos dados quando você acessa seus objetos. Portanto, você não precisa manter um código para executar a criptografia e a descriptografia de dados. A única coisa que você precisa fazer é gerenciar as chaves de criptografia fornecidas. A maioria dos casos de uso modernos no Amazon S3 não usa mais o SSE-C porque esse tipo de criptografia não tem a flexibilidade da criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3) ou da criptografia do lado do servidor com chaves do AWS KMS (SSE-KMS). Como o SSE-C exige que você forneça a chave de criptografia toda vez que interage com seus dados criptografados por SSE-C, é impossível compartilhar a chave SSE-C com outros usuários, perfis ou serviços da AWS que leem dados dos seus buckets do S3 para operar com seus dados. Devido ao amplo suporte ao SSE-KMS na AWS, a maioria das workloads modernas não usa a criptografia SSE-C porque ela não tem a flexibilidade do SSE-KMS. Para saber mais sobre o SSE-KMS, consulte [Usar criptografia do lado do servidor com o AWS KMS (SSE-KMS)](UsingKMSEncryption.md). Se você quiser evitar que a criptografia SSE-C seja usada para objetos gravados em seu bucket, é possível bloquear a criptografia SSE-C ao alterar a configuração de criptografia padrão do bucket. Quando o SSE-C é bloqueado para um bucket de uso geral, qualquer solicitação `PutObject`, `CopyObject`, `PostObject`, de multipart upload ou de replicação que especificar a criptografia SSE-C será rejeitada com o erro `HTTP 403 AccessDenied`. Para saber mais sobre como bloquear o SSE-C, consulte [Bloquear ou desbloquear o SSE-C para um bucket de uso geral](blocking-unblocking-s3-c-encryption-gpb.md). Não há cobranças adicionais pelo uso de SSE-C. No entanto, as solicitações para configurar e usar SSE-C incorrem em cobranças padrão de solicitação do Amazon S3. Para obter mais informações sobre preços, consulte [Preços do Amazon S3](https://aws.amazon.com/s3/pricing/). **Importante** A partir de abril de 2026, a AWS desabilitará a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) para todos os buckets novos. Além disso, a criptografia SSE-C será desabilitada para todos os buckets existentes em Contas da AWS que não tenham dados criptografados por SSE-C. Com essas mudanças, as poucas aplicações que precisam da criptografia SSE-C deverão habilitar deliberadamente o uso do SSE-C por meio da API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) após a criação do bucket. Nesses casos, talvez seja necessário atualizar scripts de automação, modelos do CloudFormation ou outras ferramentas de configuração de infraestrutura para definir essas configurações. Para ter mais informações, consulte a publicação do [Blog do AWS Storage](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/). ## Considerações antes de usar o SSE-C + O S3 nunca armazena a chave de criptografia quando se usa o SSE-C. Você deve fornecer a chave de criptografia sempre que quiser que alguém baixe seus dados criptografados por SSE-C no S3. + Você gerencia um mapeamento cuja chave de criptografia foi usada para criptografar objetos. Você é responsável por acompanhar a chave de criptografia que forneceu para um objeto. Isso também significa que, se você perder a chave de criptografia, perderá o objeto. + Como gerencia chaves de criptografia no lado do cliente, você gerencia todas as proteções adicionais, como a alternância de chave, no lado do cliente. + Esse esquema pode dificultar o compartilhamento da chave SSE-C com outros usuários, perfis ou serviços da AWS que você possa operar com seus dados. Devido ao amplo suporte ao SSE-KMS na AWS, a maioria das workloads modernas não usa o SSE-C porque ele não tem a flexibilidade do SSE-KMS. Para saber mais sobre o SSE-KMS, consulte [Usar criptografia do lado do servidor com o AWS KMS (SSE-KMS)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html). + Isso significa que objetos criptografados com SSE-C não podem ser descriptografados nativamente pelos serviços gerenciados da AWS. + É necessário usar HTTPS ao especificar cabeçalhos SSE-C em suas solicitações. + O Amazon S3 rejeitará todas as solicitações feitas por HTTP ao usar SSE-C. Por questões de segurança, recomendamos considerar que todas as chaves enviadas erroneamente por HTTP estão comprometidas. Descarte a chave e alterne conforme apropriado. + Se o bucket tiver o versionamento habilitado, cada versão de objeto carregada poderá ter sua própria chave de criptografia. Você é responsável por acompanhar a chave de criptografia usada para uma versão de objeto. + Não é possível usar o SSE-C no console do Amazon S3. Não é possível usar o console do Amazon S3 para fazer upload de um objeto e especificar a criptografia SSE-C. Também não é possível usar o console para atualizar (por exemplo, alterar a classe de armazenamento ou adicionar metadados) um objeto armazenado com o SSE-C. **Topics** + [Considerações antes de usar o SSE-C](#considerations-before-using-sse-c) + [Especificação de criptografia no lado do servidor com chaves fornecidas pelo cliente (SSE-C).](specifying-s3-c-encryption.md) + [Bloquear ou desbloquear o SSE-C para um bucket de uso geral](blocking-unblocking-s3-c-encryption-gpb.md) + [Perguntas frequentes sobre a configuração padrão do SSE-C para novos buckets](default-s3-c-encryption-setting-faq.md) # Especificação de criptografia no lado do servidor com chaves fornecidas pelo cliente (SSE-C). Para usar a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C), primeiro verifique se o SSE-C não é um tipo de criptografia bloqueado na configuração padrão de criptografia do bucket de uso geral do Amazon S3. Se bloqueado, é necessário habilitar esse tipo de criptografia atualizando a configuração de criptografia padrão para o bucket. Em seguida, você pode usar o SSE-C em suas solicitações de upload transmitindo os cabeçalhos necessários. Consulte [Ações do Amazon S3 que permitem a gravação de dados com o SSE-C](#amazon-s3-actions-that-support-writing-data-with-sse-c) e inclua os [Cabeçalhos de API do S3 necessários para solicitações de criptografia e descriptografia de objetos com SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests). Quando você faz upload de um objeto que especifica o SSE-C, o Amazon S3 usa a chave de criptografia fornecida para aplicar a criptografia AES-256 aos seus dados. Depois, o Amazon S3 remove a chave de criptografia da memória. Quando você recupera um objeto, deve fornecer a mesma chave de criptografia como parte de sua solicitação. O Amazon S3 primeiro verifica se a chave de criptografia fornecida é correspondente, depois decifra o objeto antes de retornar os dados de objeto. Antes de usar o SSE-C, verifique se você analisou as informações em [Considerações antes de usar o SSE-C](ServerSideEncryptionCustomerKeys.md#considerations-before-using-sse-c). **nota** O Amazon S3 não armazena a chave de criptografia que você fornece. Em vez disso, ele armazena um valor de código de autenticação de mensagens por hash (HMAC) com salt aleatório da chave de criptografia para validar solicitações futuras. O valor de HMAC com salt não pode ser usado para derivar o valor da chave de criptografia ou para decifrar o conteúdo do objeto criptografado. Isso significa que, se você perder a chave de criptografia, perderá o objeto. **Topics** + [Ações do SSE-C e cabeçalhos necessários](#sse-c-actions-and-required-headers) + [Exemplo de política de bucket para aplicar a criptografia SSE-C](#example-bucket-policy-to-enforce-sse-c-encryption) + [Pre-signed URLs e SSE-C](#ssec-and-presignedurl) + [Fazer solicitações com SSE-C](#making-requests-with-sse-c) + [Uso da API REST](#using-rest-api-sse-c) + [Uso dos AWS SDKs para especificar SSE-C para operações PUT, GET, Head e Copy](#sse-c-using-sdks) + [Uso dos AWS SDKs para especificar SSE-C para uploads fracionados](#sse-c-using-sdks-multipart-uploads) ## Ações do SSE-C e cabeçalhos necessários Para especificar o SSE-C em APIs do S3 compatíveis, é necessário transmitir parâmetros de solicitação específicos. **nota** A API `PutBucketEncryption` no Amazon S3 é usada para configurar a criptografia padrão do lado do servidor para um bucket. No entanto, `PutBucketEncryption` não permite a ativação do SSE-C como método de criptografia padrão para um bucket. O SSE-C é um método de criptografia em nível de objeto em que é necessário fornecer a chave de criptografia ao Amazon S3 com cada solicitação de upload ou download de objeto. O Amazon S3 usa essa chave para criptografar ou descriptografar o objeto durante a solicitação e, em seguida, descarta a chave. Isso significa que o SSE-C é habilitado por objeto, não como uma configuração padrão de bucket. ### Ações do Amazon S3 que permitem a gravação de dados com o SSE-C as seguintes ações ou operações de API: + [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) **nota** A replicação do S3 oferece suporte a objetos que são criptografados com SSE-C. Para obter mais informações sobre replicação de objetos criptografados, consulte [Replicar objetos criptografados (SSE-S3, SSE-KMS, DSSE-KMS, SSE-C)](replication-config-for-kms-objects.md). ### Cabeçalhos de API do S3 necessários para solicitações de criptografia e descriptografia de objetos com SSE-C É necessário fornecer os três cabeçalhos de API abaixo para criptografar ou descriptografar objetos com SSE-C: + `x-amz-server-side-encryption-customer-algorithm`: use este cabeçalho para especificar o algoritmo de criptografia. O valor do cabeçalho deve ser AES-256. + `x-amz-server-side-encryption-customer-key`: use este cabeçalho para fornecer a chave de criptografia com codificação base64 de 256 bits a ser usada pelo Amazon S3 para criptografar ou descriptografar seus dados. + `x-amz-server-side-encryption-customer-key-MD5`: use este cabeçalho para fornecer o resumo MD5 com codificação base64 de 128 bits da chave de criptografia de acordo com o RFC 1321. O Amazon S3 usa esse cabeçalho para fazer uma verificação de integridade de mensagens e conferir se a chave de criptografia foi transmitida sem erros. ### Cabeçalhos de API do S3 necessários para solicitações de cópia de objetos de origem criptografados com SSE-C É necessário fornecer os três cabeçalhos de API abaixo para copiar objetos de origem criptografados com SSE-C: + `x-amz-copy-source-server-side-encryption-customer-algorithm`: inclua este cabeçalho para especificar o algoritmo que o Amazon S3 deve usar para descriptografar o objeto de origem. Esse valor deve ser AES-256. + `x-amz-copy-source-server-side-encryption-customer-key`: inclua este cabeçalho para fornecer a chave de criptografia com codificação base64 a ser usada pelo Amazon S3 para descriptografar o objeto de origem. Essa chave de criptografia deve ser a que você forneceu ao Amazon S3 quando criou o objeto de origem. Caso contrário, o Amazon S3 não pode descriptografar o objeto. + `x-amz-copy-source-server-side-encryption-customer-key-MD5`: inclua este cabeçalho para fornecer o resumo MD5 com codificação base64 de 128 bits da chave de criptografia de acordo com RFC 1321. ## Exemplo de política de bucket para aplicar a criptografia SSE-C Para exigir SSE-C de todos os objetos gravados em um bucket do Amazon S3, é possível usar uma política de bucket. Por exemplo, a política de bucket a seguir nega permissões para upload de objeto (`s3:PutObject`) a todas as solicitações que não incluam o cabeçalho `x-amz-server-side-encryption-customer-algorithm` que solicita 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" } } } ] } ``` **Importante** Se você usar uma política de bucket para exigir SSE-C em `s3:PutObject`, deverá incluir o cabeçalho `x-amz-server-side-encryption-customer-algorithm` em todas as solicitações de carregamento fracionado (CreateMultipartUpload, UploadPart e CompleteMultipartUpload). ## Pre-signed URLs e SSE-C Você pode gerar um URL pré-assinado que pode ser usado para operações, como fazer upload de um objeto novo, recuperar um objeto existente ou recuperar metadados de objeto. Os URLs pré-assinados oferecem suporte a SSE-C da seguinte maneira: + Ao criar um URL pré-assinado, você deve especificar o algoritmo usando o cabeçalho `x-amz-server-side-encryption-customer-algorithm` no cálculo de assinatura. + Ao usar o URL pré-assinado para fazer upload de um objeto novo, recuperar um objeto existente ou recuperar somente metadados de objeto, você deve fornecer todos os cabeçalhos de criptografia na solicitação de aplicação cliente. **nota** Para objetos que não usam SSE-C, é possível gerar um URL pré-assinado e colá-lo diretamente em um navegador para acessar os dados. No entanto, não é possível fazer isso para objetos SSE-C porque, além do URL pré-assinado, você também precisa incluir cabeçalhos HTTP específicos para objetos SSE-C. Dessa forma, é possível usar URLs pré-assinados para objetos SSE-C somente de maneira programática. Para obter mais informações sobre pre-signed URLs, consulte [Baixar e fazer upload de objetos com URLs pré-assinados](using-presigned-url.md). ## Fazer solicitações com SSE-C No momento da criação do objeto com a API REST, você pode especificar a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C). Ao usar SSE-C, é necessário fornecer informações da chave de criptografia usando [Cabeçalhos de API do S3 necessários para solicitações de cópia de objetos de origem criptografados com SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c). Você pode usar bibliotecas de wrapper do AWS SDK para adicionar esses cabeçalhos à sua solicitação. Se precisar, você pode fazer com que a API REST do Amazon S3 seja chamada diretamente na aplicação. **Importante** Antes de especificar a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C), verifique se a criptografia SSE-C não está bloqueada para seu bucket de uso geral. Para obter mais informações, consulte [Bloquear ou desbloquear o SSE-C para um bucket de uso geral](blocking-unblocking-s3-c-encryption-gpb.md). **nota** Não é possível usar o console do Amazon S3 para fazer upload de um objeto e solicitar SSE-C. Também não é possível usar o console para atualizar (por exemplo, alterar a classe de armazenamento ou adicionar metadados) um objeto armazenado com o SSE-C. Para ter mais informações, consulte [Cabeçalhos de API do S3 necessários para solicitações de criptografia e descriptografia de objetos com SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests). ## Uso da API REST ### APIs REST do Amazon S3 que oferecem suporte ao SSE-C As APIs do Amazon S3 a seguir oferecem suporte à criptografia pelo servidor com chaves de criptografia fornecidas pelo cliente (SSE-C). + **Operação GET**: ao recuperar objetos usando a API GET (consulte [GET Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)), você pode especificar os cabeçalhos da solicitação. + **Operação HEAD**: para recuperar metadados de objeto usando a API HEAD (consulte [HEAD Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectHEAD.html)), você pode especificar esses cabeçalhos de solicitação. + **Operação PUT**: ao fazer upload de dados usando a API PUT (consulte [PUT Object](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPUT.html)), você pode especificar esses cabeçalhos de solicitação. + **Carregamento fracionado**: ao fazer upload de objetos grandes usando a API de carregamentos fracionados, você pode especificar esses cabeçalhos. Especifique esses cabeçalhos na solicitação de inicialização (consulte [Iniciar multipart upload](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadInitiate.html)) e em cada solicitação de upload de parte subsequente (consulte [UploadPart](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPart.html) ou [UploadPartCopy](https://docs.aws.amazon.com/AmazonS3/latest/API/mpUploadUploadPartCopy.html)). Para cada solicitação de upload de parte, as informações de criptografia devem ser as mesmas que você forneceu na solicitação iniciada do multipart upload. + **Operação POST**: ao usar uma operação POST para fazer upload de um objeto (consulte [Objeto POST](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectPOST.html)), em vez dos cabeçalhos de solicitação, você fornece as mesmas informações nos campos de formulário. + **Operação de cópia**: ao copiar um objeto (consulte [CopyObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html)), você tem um objeto de origem e um objeto de destino: + Se quiser especificar o tipo de criptografia do objeto de destino, forneça o cabeçalho de solicitação `x-amz-server-side-encryption `. + Se você quiser que o objeto de destino seja criptografado usando SSE-C, é necessário fornecer informações de criptografia usando [Cabeçalhos de API do S3 necessários para solicitações de criptografia e descriptografia de objetos com SSE-C](#s3-api-headers-required-for-sse-c-object-encryption-and-decryption-requests). + Se o objeto de origem for criptografado usando SSE-C, é necessário fornecer informações da chave de criptografia usando [Cabeçalhos de API do S3 necessários para solicitações de cópia de objetos de origem criptografados com SSE-C](#s3-api-headers-required-for-requests-to-copy-source-objects-encrypted-with-sse-c). ## Uso dos AWS SDKs para especificar SSE-C para operações PUT, GET, Head e Copy O exemplo a seguir mostra como solicitar a criptografia de servidor com chaves fornecidas pelo cliente (SSE-C) para objetos. Os exemplos executam as seguintes operações. Cada operação mostra como especificar cabeçalhos relacionados a SSE-C na solicitação: + **Colocar objeto**: faz upload de um objeto e solicita a criptografia de servidor, usando uma chave de criptografia fornecida pelo cliente. + **Obter objeto**: faz download do objeto carregado na etapa anterior. Na solicitação, você fornece as mesmas informações de criptografia fornecidas quando o objeto foi carregado. O Amazon S3 precisa dessas informações para descriptografar o objeto e para que ele possa ser devolvido a você. + **Obter metadados do objeto**: recupera os metadados do objeto. Você fornece as mesmas informações de criptografia usadas quando o objeto foi criado. + **Copiar objeto**: faz uma cópia de um objeto carregado anteriormente. Como o objeto de origem é armazenado usando SSE-C, você deve fornecer suas informações de criptografia na solicitação de cópia. Por padrão, o Amazon S3 criptografa a cópia do objeto somente se você solicitar explicitamente. Esse exemplo direciona o Amazon S3 a armazenar uma cópia criptografada do objeto. ------ #### [ Java ] **nota** Este exemplo mostra como fazer upload de um objeto em uma única operação. Ao usar a API de Multipart Upload para fazer upload de objetos grandes, você fornece informações de criptografia da mesma maneira que exibidas nesse exemplo. Para exemplos de carregamentos fracionados usando o AWS SDK para Java, consulte [Fazer upload de um objeto usando multipart upload](mpu-upload-object.md). Para adicionar informações necessárias de criptografia, inclua uma `SSECustomerKey` na solicitação. Para obter mais informações sobre a classe `SSECustomerKey`, consulte a seção REST API. Consulte instruções sobre como criar e testar uma amostra funcional em [Getting Started](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/getting-started.html) no Guia do desenvolvedor do AWS SDK para Java. **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 ] **nota** Para exemplos de upload de objetos grandes usando a API multipart upload, consulte [Fazer upload de um objeto usando multipart upload](mpu-upload-object.md) e [Uso dos AWS SDKs (API de baixo nível)](mpu-upload-object.md#mpu-upload-low-level). Para obter informações sobre como configurar e executar exemplos de código, consulte [Conceitos básicos do AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-setup.html) no *Guia do desenvolvedor do AWS SDK for .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); } } } ``` ------ ## Uso dos AWS SDKs para especificar SSE-C para uploads fracionados O exemplo da seção anterior mostra como solicitar a criptografia de servidor com a chave fornecida pelo cliente (SSE-C) nas operações PUT, GET, Head e Copy. Esta seção descreve outras APIs do Amazon S3 que oferecem suporte para SSE-C. ------ #### [ Java ] Para carregar objetos grandes, é possível usar APIs de multipart upload. Para obter mais informações, consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md). Você pode usar APIs de alto ou baixo nível para fazer upload de objetos grandes. Essas APIs oferecem suporte para cabeçalhos relacionados à criptografia na solicitação. + Ao usar a API `TransferManager` simplificada, forneça os cabeçalhos específicos de criptografia em `PutObjectRequest`. Para obter mais informações, consulte [Fazer upload de um objeto usando multipart upload](mpu-upload-object.md). + Ao usar a API de baixo nível, você fornece informações relacionadas à criptografia na `InitiateMultipartUploadRequest`, seguidas por informações de criptografia idênticas em cada `UploadPartRequest`. Você não precisa fornecer cabeçalhos específicos de criptografia na `CompleteMultipartUploadRequest`. Para ver exemplos, consulte [Uso dos AWS SDKs (API de baixo nível)](mpu-upload-object.md#mpu-upload-low-level). O exemplo a seguir usa `TransferManager` para criar objetos e mostra como fornecer informações relacionadas a SSE-C. O exemplo faz o seguinte: + Cria um objeto usando o método `TransferManager.upload()`. Na instância `PutObjectRequest`, forneça informações da chave de criptografia na solicitação. O Amazon S3 criptografa o objeto usando a chave fornecida pelo cliente. + Faz uma cópia do objeto, chamando o método `TransferManager.copy()`. O exemplo instrui o Amazon S3 a criptografar a cópia do objeto usando um novo `SSECustomerKey`. Como o objeto de origem é criptografado usando SSE-C, o `CopyObjectRequest` também fornece a chave de criptografia do objeto de origem para que o Amazon S3 possa descriptografar o objeto antes de copiá-lo. **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 ] Para carregar objetos grandes, você pode usar a API de carregamentos fracionados (consulte [Carregar e copiar objetos usando upload fracionado no Amazon S3](mpuoverview.md)). AWS O SDK for .NET fornece APIs de alto ou baixo nível para fazer upload de objetos grandes. Essas APIs oferecem suporte para cabeçalhos relacionados à criptografia na solicitação. + Ao usar a API do `Transfer-Utility `de alto nível, você fornece os cabeçalhos específicos de criptografia na `TransferUtilityUploadRequest`, conforme mostrado. Para obter exemplos de código, consulte [Fazer upload de um objeto usando multipart upload](mpu-upload-object.md). ``` TransferUtilityUploadRequest request = new TransferUtilityUploadRequest() { FilePath = filePath, BucketName = existingBucketName, Key = keyName, // Provide encryption information. ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256, ServerSideEncryptionCustomerProvidedKey = base64Key, }; ``` + Ao usar a API de baixo nível, você fornece informações relacionadas à criptografia na solicitação para iniciar o multipart upload, seguidas por informações de criptografia idênticas nas solicitações subsequentes de upload de parte. Você não precisa fornecer cabeçalhos específicos de criptografia na solicitação de multipart upload completo. Para ver exemplos, consulte [Uso dos AWS SDKs (API de baixo nível)](mpu-upload-object.md#mpu-upload-low-level). O seguinte é um exemplo de multipart upload de baixo nível que faz uma cópia de um objeto grande existente. No exemplo, o objeto a ser copiado é armazenado no Amazon S3 usando o SSE-C, e você deseja salvar o objeto de destino também usando o SSE-C. No exemplo, faça o seguinte: + Inicie uma solicitação de multipart upload fornecendo uma chave de criptografia e as informações relacionadas. + Forneça as chaves de criptografia de objeto de origem e de destino e as informações relacionadas na `CopyPartRequest`. + Obtenha o tamanho do objeto de origem a ser copiado recuperando os metadados do objeto. + Faça upload dos objetos em partes de 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); } } } } ``` ------ # Bloquear ou desbloquear o SSE-C para um bucket de uso geral A maioria dos casos de uso modernos no Amazon S3 não usa mais o SSE-C com chaves gerenciadas pelo cliente (SSE-C) porque esse tipo de criptografia não tem a flexibilidade da criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3) ou da criptografia do lado do servidor com chaves do AWS KMS (SSE-KMS). Como o SSE-C exige que você forneça a chave de criptografia toda vez que interage com seus dados criptografados por SSE-C, é impossível compartilhar a chave SSE-C com outros usuários, perfis ou serviços da AWS que leem dados dos seus buckets do S3 para operar com seus dados. Para limitar os tipos de criptografia do lado do servidor que é possível usar em buckets de uso geral, você pode optar por bloquear as solicitações de gravação SSE-C atualizando a configuração de criptografia padrão para os buckets. Essa configuração em nível de bucket bloqueia solicitações de upload de objetos que especificam SSE-C. Quando o SSE-C é bloqueado para um bucket, qualquer solicitação `PutObject`, `CopyObject`, `PostObject` ou de multipart upload ou replicação que especifique a criptografia SSE-C será rejeitada com um erro HTTP 403 `AccessDenied`. Essa configuração é um parâmetro na API `PutBucketEncryption` e também poderá ser atualizada usando o console do S3, a AWS CLI e SDKs da AWS se você tiver a permissão `s3:PutEncryptionConfiguration`. Os valores válidos são `SSE-C`, que bloqueia a criptografia SSE-C para o bucket de uso geral, e `NONE`, que permite o uso do SSE-C para gravações no bucket. **Importante** A partir de abril de 2026, a AWS desabilitará a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) para todos os buckets novos. Além disso, a criptografia SSE-C será desabilitada para todos os buckets existentes em Contas da AWS que não tenham dados criptografados por SSE-C. Com essas mudanças, as poucas aplicações que precisam da criptografia SSE-C deverão habilitar deliberadamente o uso do SSE-C por meio da API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) após a criação do bucket. Nesses casos, talvez seja necessário atualizar scripts de automação, modelos do CloudFormation ou outras ferramentas de configuração de infraestrutura para definir essas configurações. Para ter mais informações, consulte a publicação do [Blog do AWS Storage](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/). ## Permissões Use a `PutBucketEncryption` API ou o console do S3, SDKs da AWS ou a AWS CLI para bloquear ou desbloquear tipos de criptografia para um bucket de uso geral. É necessário ter a seguinte permissão: + `s3:PutEncryptionConfiguration` Use a `GetBucketEncryption` API ou o console do S3, SDKs da AWS ou a AWS CLI para visualizar os tipos de criptografia bloqueados para um bucket de uso geral. É necessário ter a seguinte permissão: + `s3:GetEncryptionConfiguration` ## Considerações antes de bloquear a criptografia SSE-C Depois de bloquear o SSE-C para qualquer bucket, o seguinte comportamento de criptografia será aplicado: + Não há alteração na criptografia dos objetos que existiam no bucket antes de você bloquear a criptografia SSE-C. + Depois de bloquear a criptografia SSE-C, você pode continuar fazendo solicitações GetObject e HeadObject em objetos preexistentes criptografados com SSE-C, desde que forneça os cabeçalhos SSE-C necessários nas solicitações. + Quando o SSE-C é bloqueado para um bucket, qualquer solicitação `PutObject`, `CopyObject`, `PostObject` ou de multipart upload que especificar a criptografia SSE-C será rejeitada com o erro HTTP 403 `AccessDenied`. + Se um bucket de destino para replicação tiver o SSE-C bloqueado e os objetos de origem que estão sendo replicados forem criptografados com o SSE-C, a replicação falhará com o erro HTTP 403 `AccessDenied`. Se você quiser verificar se está usando o SSE-C em qualquer um dos seus buckets antes de bloquear esse tipo de criptografia, use ferramentas como o [AWS CloudTrail](https://aws.amazon.com/cloudtrail/) para monitorar o acesso aos seus dados. Esta [publicação de blog](https://aws.amazon.com/blogs/storage/auditing-amazon-s3-server-side-encryption-methods-for-object-uploads/) mostra como auditar métodos de criptografia para uploads de objetos em tempo real. Você também pode consultar este [artigo do re:Post](https://repost.aws/articles/ARhGC12rOiTBCKHcAe9GZXCA/how-to-detect-existing-use-of-sse-c-in-your-amazon-s3-buckets) para saber como consultar os relatórios do Inventário S3 para ver se você tem algum objeto criptografado com SSE-C. ### Etapas É possível bloquear ou desbloquear a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) para um bucket de uso geral usando o console do Amazon S3, a AWS Command Line Interface (AWS CLI), a API REST do Amazon S3 e SDKs da AWS. ### Usar o console do S3 Para bloquear ou desbloquear a criptografia SSE-C para um bucket usando o console Amazon S3: 1. Faça login no Console de Gerenciamento da AWS e abra o console do Amazon S3 em https://console.aws.amazon.com/s3/. 1. No painel de navegação à esquerda, escolha **Buckets de uso geral**. 1. Selecione o bucket para o qual você gostaria de bloquear a criptografia SSE-C. 1. Selecione a guia **Propriedades** do bucket. 1. Navegue até o painel de propriedades **Criptografia padrão** do bucket e selecione **Editar**. 1. Na seção **Tipos de criptografia bloqueados**, marque a caixa ao lado de **Criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) para bloquear a criptografia SSE-C** ou desmarque essa caixa para permitir o SSE-C. 1. Escolha **Salvar alterações**. ### Como usar o AWS CLI Para instalar a AWS CLI, consulte [Instalar ou atualizar a versão mais recente da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) no *Guia do usuário da versão 2 da AWS Command Line Interface*. O exemplo da CLI a seguir mostra como bloquear ou desbloquear a criptografia SSE-C para um bucket de uso geral usando a AWS CLI. Para usar o comando, substitua os *espaços reservados para entrada do usuário* por suas próprias informações. **Solicitação para bloquear a criptografia SSE-C para um bucket de uso geral:** ``` aws s3api put-bucket-encryption \ --bucket amzn-s3-demo-bucket \ --server-side-encryption-configuration '{ "Rules": [{ "BlockEncryptionTypes": { "EncryptionType": "SSE-C" } }] }' ``` **Solicitação para habilitar o uso da criptografia SSE-C em um bucket de uso geral:** ``` aws s3api put-bucket-encryption \ --bucket amzn-s3-demo-bucket \ --server-side-encryption-configuration '{ "Rules": [{ "BlockEncryptionTypes": { "EncryptionType": "NONE" } }] }' ``` ## Usar SDKs da AWS ------ #### [ SDK for Java 2.x ] Os seguintes exemplos mostram como bloquear ou desbloquear gravações da criptografia SSE-C em buckets de uso geral usando os SDKs da AWS: **Exemplo: solicitação PutBucketEncryption que define a configuração de criptografia padrão como SSE-S3 e bloqueia o 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))); ``` **Exemplo: solicitação PutBucketEncryption que define a configuração de criptografia padrão como SSE-S3 e desbloqueia o 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 ] **Exemplo: solicitação PutBucketEncryption que define a configuração de criptografia padrão como SSE-S3 e bloqueia o SSE-C** ``` s3 = boto3.client("s3") s3.put_bucket_encryption( Bucket="amzn-s3-demo-bucket", ServerSideEncryptionConfiguration={ "Rules":[{ "ApplyServerSideEncryptionByDefault": { "SSEAlgorithm": "AES256" }, "BlockedEncryptionTypes": { "EncryptionType": ["SSE-C"] } }] } ) ``` **Exemplo: solicitação PutBucketEncryption que define a configuração de criptografia padrão como SSE-S3 e desbloqueia o SSE-C** ``` s3 = boto3.client("s3") s3.put_bucket_encryption( Bucket="amzn-s3-demo-bucket", ServerSideEncryptionConfiguration={ "Rules":[{ "ApplyServerSideEncryptionByDefault": { "SSEAlgorithm": "AES256" }, "BlockedEncryptionTypes": { "EncryptionType": ["NONE"] } }] } ) ``` ------ ## Uso da API REST Para ter informações sobre a compatibilidade oferecida pela API REST do Amazon S3 para bloquear ou desbloquear a criptografia SSE-C para um bucket de uso geral, consulte a seguinte seção na *Referência de API do Amazon Simple Storage Service*: + Tipo de dados [BlockedEncryptionTypes](https://docs.aws.amazon.com/AmazonS3/latest/API/API_BlockedEncryptionTypes.html) usado no tipo de dados [ServerSideEncryptionRule](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ServerSideEncryptionRule.html) das operações de API [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) e [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html). # Perguntas frequentes sobre a configuração padrão do SSE-C para novos buckets **Importante** A partir de abril de 2026, a AWS desabilitará a criptografia do lado do servidor com chaves fornecidas pelo cliente (SSE-C) para todos os buckets novos. Além disso, a criptografia SSE-C será desabilitada para todos os buckets existentes em Contas da AWS que não tenham dados criptografados por SSE-C. Com essas mudanças, as poucas aplicações que precisam da criptografia SSE-C deverão habilitar deliberadamente o uso do SSE-C por meio da API [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) após a criação do bucket. Nesses casos, talvez seja necessário atualizar scripts de automação, modelos do CloudFormation ou outras ferramentas de configuração de infraestrutura para definir essas configurações. Para ter mais informações, consulte a publicação do [Blog do AWS Storage](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/). As seções a seguir respondem a perguntas sobre essa atualização. **1. Em abril de 2026, a nova configuração padrão do SSE-C entrará em vigor para todos os buckets recém-criados?** Sim. Ao longo de abril de 2026, a nova configuração padrão será implementada gradualmente em todas as regiões da AWS. **2. Quanto tempo vai levar para que esse lançamento abranja todas as regiões da AWS?** Essa atualização levará várias semanas para ser totalmente lançada. Publicaremos uma postagem em Novidades quando começarmos a implantar essa atualização. **3. Como saberei que a atualização foi concluída?** É possível determinar facilmente se a alteração foi concluída em sua região da AWS criando um bucket e chamando a operação de API [GetBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html) para determinar se a criptografia SSE-C está desabilitada. Depois que a atualização for concluída, a criptografia SSE-C será desabilitada automaticamente por padrão em todos os novos buckets de uso geral. Você pode ajustar essas configurações depois de criar o bucket do S3 chamando a operação de API [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html). **4. O Amazon S3 vai atualizar as configurações dos meus buckets existentes?** Se sua conta da AWS não tiver nenhum objeto criptografado com SSE-C, a AWS desabilitará a criptografia SSE-C em todos os seus buckets atuais. Se algum bucket na sua conta da AWS tiver objetos criptografados com SSE-C, a AWS não alterará as configurações em nenhum dos buckets dessa conta. Depois que a alteração `CreateBucket` for concluída em sua região da AWS, a nova configuração padrão será aplicada a todos os novos buckets de uso geral. **5. Posso desabilitar a criptografia SSE-C para meus buckets antes que a atualização seja concluída?** Sim. Você pode desabilitar a criptografia SSE-C para qualquer bucket chamando a operação de API [PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html) e especificando o novo cabeçalho `BlockedEncryptionTypes`. **6. Posso usar o SSE-C para criptografar dados em meus novos buckets?** Sim. A maioria dos casos de uso modernos no Amazon S3 não usa mais o SSE-C porque esse tipo de criptografia não tem a flexibilidade da criptografia do lado do servidor com chaves gerenciadas pelo Amazon S3 (SSE-S3) ou da criptografia do lado do servidor com chaves do AWS KMS (SSE-KMS). Se precisar usar a criptografia SSE-C em um novo bucket, é possível outro bucket e, em seguida, habilitar o uso da criptografia SSE-C em uma solicitação `PutBucketEncryption` separada. **Exemplo** ``` 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\] } }] }' ``` **nota** Para chamar a API `PutBucketEncryption`, é necessário ter a permissão `s3:PutEncryptionConfiguration`. **7. Como o bloqueio do SSE-C afeta as solicitações ao meu bucket?** Quando o SSE-C é bloqueado para um bucket, qualquer solicitação `PutObject`, `CopyObject`, `PostObject`, de multipart upload ou de replicação que especificar a criptografia SSE-C será rejeitada com o erro HTTP 403 `AccessDenied`.