Especificações de chave assimétrica

Os tópicos a seguir fornecem informações técnicas sobre as especificações de chave com as quais o AWS KMS tem compatibilidade para chaves do KMS assimétricas. As informações sobre a especificação de chave SYMMETRIC_DEFAULT para chaves de criptografia simétrica estão incluídas para comparação.

Especificações da chave RSA

Quando uma especificação de chave RSA é usada, o AWS KMS cria uma chave do KMS simétrica com um par de chaves RSA. A chave privada nunca deixa o AWS KMS descriptografado. É possível usar a chave pública no AWS KMS ou fazer download da chave pública para usar fora do AWS KMS.

Atenção

Ao criptografar dados fora do AWS KMS, certifique-se de que você pode descriptografar o texto cifrado. Se você usar a chave pública de uma chave do KMS que foi excluída do AWS KMS, a chave pública de uma chave do KMS configurada para assinatura e verificação ou um algoritmo de criptografia não compatível com a chave do KMS, os dados se tornarão irrecuperáveis.

No AWS KMS, é possível usar chaves do KMS assimétricas com pares de chaves RSA para criptografia e descriptografia ou para assinatura e verificação, mas não para ambos. Essa propriedade, conhecida como uso de chave, é determinada separadamente da especificação de chave, mas você deve tomar essa decisão antes de escolher uma especificação de chave.

O AWS KMS oferece suporte às seguintes especificações de chave para criptografia e descriptografia ou para assinatura e verificação:

• RSA_2048

• RSA_3072

• RSA_4096

As especificações de chave RSA diferem no tamanho da chave RSA em bits. A especificação da chave RSA escolhida deve ser determinada pelos padrões de segurança ou pelos requisitos da tarefa. Em geral, use a maior chave que seja prática e acessível para sua tarefa. As operações criptográficas em chaves do KMS com diferentes especificações de chave RSA são cobradas de maneira diferente. Para obter informações sobre a definição de preço do AWS KMS, consulte Definição de preço do serviço de gerenciamento de chaves da AWS. Para obter mais informações sobre cotas de solicitações, consulte Cotas de solicitações.

Especificações de chave RSA para criptografia e descriptografia

Quando uma chave do KMS RSA assimétrica é usada para criptografia e descriptografia, você criptografa com a chave pública e descriptografa com a chave privada. Quando a operação Encrypt é chamada no AWS KMS para uma chave do KMS RSA, o AWS KMS usa a chave pública no par de chaves RSA e o algoritmo de criptografia especificado para criptografar seus dados. Para descriptografar o texto cifrado, chame a operação Decrypt e especifique a mesma chave do KMS e o mesmo algoritmo de criptografia. O AWS KMS usará a chave privada no par de chaves RSA para descriptografar seus dados.

Também é possível fazer download da chave pública e usá-la para criptografar dados fora do AWS KMS. Certifique-se de usar um algoritmo de criptografia compatível com o AWS KMS para chaves do KMS RSA. Para descriptografar o texto cifrado, chame a função Decrypt com a mesma chave do KMS e o mesmo algoritmo de criptografia.

O AWS KMS é compatível com dois algoritmos de criptografia para chaves do KMS com especificações de chave RSA. Esses algoritmos, que são definidos no PKCS nº 1 v2.2, diferem na função de hash que usam internamente, No AWS KMS, os algoritmos RSAES_OAEP sempre usam a mesma função de hash para finalidades de hash e para a função de geração de máscara (MGF1). É obrigatório especificar um algoritmo de criptografia ao chamar as operações Encrypt e Decrypt. É possível escolher um algoritmo diferente para cada solicitação.

Algoritmos de criptografia compatíveis com especificações de chave RSA
Algoritmo de criptografia	Descrição do algoritmo
RSAES_OAEP_SHA_1	PKCS nº 1 v2.2, Seção 7.1. Criptografia RSA com padding OAEP usando SHA-1 para a função de hash e a função de geração de máscara MGF1 com um rótulo vazio.
RSAES_OAEP_SHA_256	PKCS nº 1, Seção 7.1. Criptografia RSA com padding OAEP usando SHA-256 para a função de hash e a função de geração de máscara MGF1 com um rótulo vazio.

Não é possível configurar uma chave do KMS para usar um algoritmo de criptografia específico. No entanto, você pode usar a condição kms: EncryptionAlgorithm policy para especificar os algoritmos de criptografia que os principais podem usar com a chave KMS.

Para obter os algoritmos de criptografia de uma chave KMS, visualize a configuração criptográfica da chave KMS no AWS KMS console ou use a operação. DescribeKey AWS KMStambém fornece a especificação da chave e os algoritmos de criptografia quando você baixa sua chave pública, seja no AWS KMS console ou usando a GetPublicKeyoperação.

Você pode escolher uma especificação de chave RSA com base no tamanho dos dados do texto não criptografado que pode ser criptografado em cada solicitação. A tabela a seguir mostra o tamanho máximo, em bytes, do texto não criptografado que pode ser criptografado em uma única chamada para a operação Encrypt. Os valores diferem de acordo com a especificação de chave e com o algoritmo de criptografia. Para fins comparativos, é possível usar uma chave do KMS de criptografia simétrica para criptografar até 4.096 bytes de uma vez.

Para calcular o tamanho máximo do texto não criptografado em bytes para esses algoritmos, use a seguinte fórmula: (tamanho_da_chave_em_bits/8) - (2 * tamanho_de_hash_em_bits/8) - 2. Por exemplo, para RSA_2048 com SHA-256, o tamanho máximo de texto não criptografado em bytes é de (2048/8) - (2 * 256/8) -2 = 190.

Tamanho máximo de texto não criptografado (em bytes) em uma operação Encrypt
	Algoritmo de criptografia
Especificação da chave	RSAES_OAEP_SHA_1	RSAES_OAEP_SHA_256
RSA_2048	214	190
RSA_3072	342	318
RSA_4096	470	446

Especificações de chave RSA para assinatura e verificação

Quando uma chave do KMS RSA assimétrica é usada para assinatura e verificação, você gera a assinatura para uma mensagem com uma chave privada e verifica a assinatura com a chave pública.

Quando você chama a operação Sign no AWS KMS para uma chave do KMS assimétrica, o AWS KMS usa a chave privada no par de chaves RSA, a mensagem e o algoritmo de assinatura especificado para gerar uma assinatura. Para verificar a assinatura, chame a operação Verify. Especifique a assinatura, a mesma chave do KMS, a mesma mensagem e o mesmo algoritmo de assinatura. O AWS KMS usará a chave pública no par de chaves RSA para verificar a assinatura. Também é possível fazer download da chave pública e usá-la para verificar a assinatura fora do AWS KMS.

O AWS KMS oferece suporte aos algoritmos de assinatura a seguir para todas as chaves do KMS com uma especificação de chave RSA. É obrigatório especificar um algoritmo de assinatura ao chamar as operações Sign e Verify. É possível escolher um algoritmo diferente para cada solicitação. Ao assinar com pares de chaves RSA, os algoritmos RSASSA-PSS são preferidos. Incluímos algoritmos RSASSA-PKCS1-v1_5 para compatibilidade com aplicações existentes.

Algoritmos de assinatura compatíveis com especificações de chave RSA
Algoritmo de assinatura	Descrição do algoritmo
RSASSA_PSS_SHA_256	PKCS nº 1 v2.2, Seção 8.1, assinatura RSA com padding PSS usando SHA-256 para a função de resumo de mensagens e para a função de geração de máscara MGF1 com um sal de 256 bits.
RSASSA_PSS_SHA_384	PKCS nº 1 v2.2, Seção 8.1, assinatura RSA com padding PSS usando SHA-384 para o a função de resumo de mensagens e a função de geração de máscara MGF1 com um sal de 384 bits
RSASSA_PSS_SHA_512	PKCS nº 1 v2.2, Seção 8.1, assinatura RSA com padding PSS usando SHA-512 para a função de resumo de mensagens e a função de geração de máscara MGF1 com um sal de 512 bits
RSASSA_PKCS1_V1_5_SHA_256	PKCS nº 1 v2.2, Seção 8.2, assinatura RSA com PKCS nº 1 v1.5 padding e SHA-256
RSASSA_PKCS1_V1_5_SHA_384	PKCS nº 1 v2.2, Seção 8.2, assinatura RSA com PKCS nº 1 v1.5 padding e SHA-384
RSASSA_PKCS1_V1_5_SHA_512	PKCS nº 1 v2.2, Seção 8.2, assinatura RSA com PKCS nº 1 v1.5 padding e SHA-512

Não é possível configurar uma chave do KMS para usar algoritmos de assinatura específicos. No entanto, você pode usar a condição kms: SigningAlgorithm policy para especificar os algoritmos de assinatura que os diretores podem usar com a chave KMS.

Para obter os algoritmos de assinatura de uma chave KMS, visualize a configuração criptográfica da chave KMS no AWS KMS console ou usando a operação. DescribeKey AWS KMStambém fornece a especificação da chave e os algoritmos de assinatura quando você baixa sua chave pública, seja no AWS KMS console ou usando a GetPublicKeyoperação.

Especificações da chave de curva elíptica

Quando uma especificação de chave de curva elíptica (ECC) é usada, o AWS KMS cria uma chave do KMS assimétrica com um par de chaves de ECC para assinatura e verificação. A chave privada que gera a assinatura nunca deixa o AWS KMS descriptografada. É possível usar a chave pública para verificar assinaturas no AWS KMS ou fazer download da chave pública para usar fora do AWS KMS.

O AWS KMS é compatível com especificações de chave de ECC a seguir para chaves do KMS assimétricas.

• Pares de chaves de curva elíptica assimétricas recomendadas pelo NIST (assinatura e verificação)

  • ECC_NIST_P256 (secp256r1)

  • ECC_NIST_P384 (secp384r1)

  • ECC_NIST_P521 (secp521r1)

• Outros pares de chaves de curva elíptica assimétricas (assinatura e verificação)

  • ECC_SECG_P256K1 (secp256k1), normalmente usada para criptomoedas.

A especificação da chave ECC escolhida deve ser determinada pelos padrões de segurança ou pelos requisitos da tarefa. Em geral, use a curva com mais pontos que seja prática e acessível para sua tarefa.

Se você estiver criando uma chave do KMS assimétrica para usar com criptomoedas, use a especificação de chave ECC_SECG_P256K1. Também é possível usar essa especificação de chave para outros fins, mas ela é exigida para Bitcoin e para outras criptomoedas.

As chaves do KMS com especificações de chave de ECC diferentes são cobradas de maneira diferente e estão sujeitas a diferentes cotas de solicitações. Para obter mais informações sobre a definição de preço do AWS KMS, consulte Definição de preço do AWS Key Management Service. Para obter mais informações sobre cotas de solicitações, consulte Cotas de solicitações.

A tabela a seguir mostra os algoritmos de assinatura compatíveis com o AWS KMS para cada especificação de chave ECC. Não é possível configurar uma chave do KMS para usar algoritmos de assinatura específicos. No entanto, você pode usar a condição kms: SigningAlgorithm policy para especificar os algoritmos de assinatura que os diretores podem usar com a chave KMS.

Algoritmos de assinatura compatíveis para especificações de chave ECC
Especificação da chave	Algoritmo de assinatura	Descrição do algoritmo
ECC_NIST_P256	ECDSA_SHA_256	NIST FIPS 186-4, Seção 6.4, assinatura ECDSA usando a curva especificada pela chave e SHA-256 para o resumo de mensagens.
ECC_NIST_P384	ECDSA_SHA_384	NIST FIPS 186-4, Seção 6.4, assinatura ECDSA usando a curva especificada pela chave e SHA-384 para o resumo de mensagens.
ECC_NIST_P521	ECDSA_SHA_512	NIST FIPS 186-4, Seção 6.4, assinatura ECDSA usando a curva especificada pela chave e SHA-512 para o resumo de mensagens.
ECC_SECG_P256K1	ECDSA_SHA_256	NIST FIPS 186-4, Seção 6.4, assinatura ECDSA usando a curva especificada pela chave e SHA-256 para o resumo de mensagens.

Especificação de chave SM2 (somente nas regiões da China)

A especificação de chave SM2 é uma especificação chave de curva elíptica definida dentro da série de especificações GM/T publicada pelo Office of State Commercial Cryptography Administration (OSCCA) da China. A especificação de chave SM2 está disponível somente nas regiões da China. Quando uma especificação de chave SM2 é usada, o AWS KMS cria uma chave do KMS simétrica com um par de chaves SM2. É possível usar esse par chaves SM2 no AWS KMS ou baixar a chave pública para usar fora do AWS KMS.

Ao contrário da especificação de chave ECC, chave do KMS SM2 pode ser usada para assinatura e verificação ou para criptografia e descriptografia. Você deve especificar o uso da chave ao criar a chave do KMS, e não será possível alterá-lo após a criação da chave.

O AWS KMS é compatível com os seguintes algoritmos de criptografia e assinatura SM2:

• Algoritmo de criptografia SM2PKE

  O SM2PKE é um algoritmo de criptografia baseado em curva elíptica definido pelo OSCCA no GM/T 0003.4-2012.

• Algoritmo de criptografia SM2DSA

  O SM2DSA é um algoritmo de assinatura baseado em curva elíptica definido pelo OSCCA em GM/T 0003.2-2012. O SM2DSA requer um ID distinto criptografado em hash com o algoritmo de hash SM3 e, em seguida, é combinado com a mensagem, ou o resumo da mensagem, que você transmitiu para o AWS KMS. Esse valor concatenado é então criptografado em hash e assinado pelo AWS KMS.

Operações offline com SM2 (somente nas regiões da China)

Você pode baixar a chave pública do seu par de chaves SM2 para uso em operações offline, ou seja, operações fora do AWS KMS. Porém, ao usar sua chave pública SM2 offline, talvez seja necessário fazer conversões e cálculos extras manualmente. Operações SM2DSA podem exigir que você forneça um ID distintivo ou calcule um resumo de mensagem. Operações de criptografia SM2PKE podem exigir que você converta a saída de texto cifrado bruto em um formato aceitável pelo AWS KMS.

Para ajudar com essas operações, a classe SM2OfflineOperationHelper para Java tem métodos que realizam as tarefas para você. Essa classe auxiliar pode ser usada como modelo para outros provedores criptográficos.

Importante

O código de referência SM2OfflineOperationHelper foi projetado para ser compatível com o Bouncy Castle versão 1.68. Para obter ajuda com outras versões, entre em contato com bouncycastle.org.

Verificação offline com pares de chaves SM2 (somente nas regiões da China)

Para verificar uma assinatura fora do AWS KMS com uma chave pública SM2, é necessário especificar o ID distintivo. Quando você transmite uma mensagem bruta, MessageType:RAW, para a API Sign, o AWS KMS usa o ID distintivo padrão, 1234567812345678, definido pelo OSCCA em GM/T 0009-2012. Você não pode especificar seu próprio ID de distinção no AWS KMS.

Porém, se estiver gerando um resumo de mensagens fora do AWS, você poderá especificar seu próprio ID distintivo e, em seguida, transmitir o resumo de mensagem, MessageType:DIGEST, para o AWS KMS assinar. Para isso, altere o valor de DEFAULT_DISTINGUISHING_ID na classe SM2OfflineOperationHelper. O ID distintivo especificado pode ser qualquer string de até 8.192 caracteres. Depois que o AWS KMS assinar o resumo de mensagem, você precisará desse resumo de mensagem ou da mensagem e do ID distintivo utilizados no cálculo do resumo para verificá-lo offline.

Classe SM2OfflineOperationHelper

No AWS KMS, as conversões de texto cifrado bruto e os cálculos de resumos de mensagem SM2DSA ocorrem automaticamente. Nem todos os provedores criptográficos implementam o SM2 da mesma maneira. Algumas bibliotecas, como a OpenSSL versões 1.1.1 e posteriores, realizam essas ações automaticamente. O AWS KMS confirma esse comportamento em testes com a OpenSSL versão 3.0. Use a seguinte classe SM2OfflineOperationHelper com bibliotecas, como a Bouncy Castle, que exigem que você faça essas conversões e cálculos manualmente.

A classe SM2OfflineOperationHelper fornece métodos para as seguintes operações:

• Cálculo de resumo de mensagem

  Para gerar um resumo de mensagem offline para uso em uma verificação offline ou para transmissão ao AWS KMS para assinatura, use o método calculateSM2Digest. O método calculateSM2Digest gera um resumo de mensagem com o algoritmo de hash SM3. A GetPublicKeyAPI retorna sua chave pública em formato binário. Você deve analisar a chave binária em um Java PublicKey. Forneça a chave pública analisada com a mensagem. O método combina automaticamente sua mensagem com o ID distintivo padrão, 1234567812345678, mas você pode definir seu próprio ID distintivo alterando o valor de DEFAULT_DISTINGUISHING_ID.

• Verificar

  Para verificar uma assinatura offline, use o método offlineSM2DSAVerify. O método offlineSM2DSAVerify usa o resumo de mensagem calculado com base no ID distintivo especificado e a mensagem original fornecida para verificar a assinatura digital. A GetPublicKeyAPI retorna sua chave pública em formato binário. Você deve analisar a chave binária em um Java PublicKey. Forneça a chave pública analisada com a mensagem original e a assinatura que você deseja verificar. Para obter mais detalhes, consulte Verificação offline com pares de chaves SM2.

• Encrypt

  Para criptografar texto sem formatação offline, use o método offlineSM2PKEEncrypt. Ele garante que o texto cifrado esteja em um formato que o AWS KMS possa descriptografar. O método offlineSM2PKEEncrypt criptografa o texto simples e depois converte o texto cifrado bruto produzido por SM2PKE no formato ASN.1. A GetPublicKeyAPI retorna sua chave pública em formato binário. Você deve analisar a chave binária em um Java PublicKey. Forneça a chave pública analisada com o texto simples que você deseja criptografar.

  Se não tiver certeza de que a conversão é necessário, use a seguinte operação OpenSSL para testar o formato do texto cifrado. Se a operação falhar, significa que você precisa converter o texto cifrado no formato ASN.1.

  openssl asn1parse -inform DER -in ciphertext.der

Por padrão, a classe SM2OfflineOperationHelper usa o ID distintivo padrão, 1234567812345678, ao gerar resumos de mensagens para operações SM2DSA.

package com.amazon.kms.utils;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;

import org.bouncycastle.crypto.CryptoException;
import org.bouncycastle.jce.interfaces.ECPublicKey;

import java.util.Arrays;

import org.bouncycastle.asn1.ASN1EncodableVector;
import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.DEROctetString;
import org.bouncycastle.asn1.DERSequence;
import org.bouncycastle.asn1.gm.GMNamedCurves;
import org.bouncycastle.asn1.x9.X9ECParameters;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.params.ParametersWithID;
import org.bouncycastle.crypto.params.ParametersWithRandom;
import org.bouncycastle.crypto.signers.SM2Signer;
import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;

public class SM2OfflineOperationHelper {
    // You can change the DEFAULT_DISTINGUISHING_ID value to set your own distinguishing ID,
    // the DEFAULT_DISTINGUISHING_ID can be any string up to 8,192 characters long.
    private static final byte[] DEFAULT_DISTINGUISHING_ID = "1234567812345678".getBytes(StandardCharsets.UTF_8);
    private static final X9ECParameters SM2_X9EC_PARAMETERS = GMNamedCurves.getByName("sm2p256v1");

    // ***calculateSM2Digest***
    // Calculate message digest
    public static byte[] calculateSM2Digest(final PublicKey publicKey, final byte[] message) throws
            NoSuchProviderException, NoSuchAlgorithmException {
        final ECPublicKey ecPublicKey = (ECPublicKey) publicKey;

        // Generate SM3 hash of default distinguishing ID, 1234567812345678
        final int entlenA = DEFAULT_DISTINGUISHING_ID.length * 8;
        final byte [] entla = new byte[] { (byte) (entlenA & 0xFF00), (byte) (entlenA & 0x00FF) };
        final byte [] a = SM2_X9EC_PARAMETERS.getCurve().getA().getEncoded();
        final byte [] b = SM2_X9EC_PARAMETERS.getCurve().getB().getEncoded();
        final byte [] xg = SM2_X9EC_PARAMETERS.getG().getXCoord().getEncoded();
        final byte [] yg = SM2_X9EC_PARAMETERS.getG().getYCoord().getEncoded();
        final byte[] xa = ecPublicKey.getQ().getXCoord().getEncoded();
        final byte[] ya = ecPublicKey.getQ().getYCoord().getEncoded();
        final byte[] za = MessageDigest.getInstance("SM3", "BC")
                .digest(ByteBuffer.allocate(entla.length + DEFAULT_DISTINGUISHING_ID.length + a.length + b.length + xg.length + yg.length +
                        xa.length + ya.length).put(entla).put(DEFAULT_DISTINGUISHING_ID).put(a).put(b).put(xg).put(yg).put(xa).put(ya)
                        .array());

        // Combine hashed distinguishing ID with original message to generate final digest
        return MessageDigest.getInstance("SM3", "BC")
                .digest(ByteBuffer.allocate(za.length + message.length).put(za).put(message)
                        .array());
    }

    // ***offlineSM2DSAVerify***
    // Verify digital signature with SM2 public key
    public static boolean offlineSM2DSAVerify(final PublicKey publicKey, final byte [] message,
            final byte [] signature) throws InvalidKeyException {
        final SM2Signer signer = new SM2Signer();
        CipherParameters cipherParameters = ECUtil.generatePublicKeyParameter(publicKey);
        cipherParameters = new ParametersWithID(cipherParameters, DEFAULT_DISTINGUISHING_ID);
        signer.init(false, cipherParameters);
        signer.update(message, 0, message.length);
        return signer.verifySignature(signature);
    }

    // ***offlineSM2PKEEncrypt***
    // Encrypt data with SM2 public key
    public static byte[] offlineSM2PKEEncrypt(final PublicKey publicKey, final byte [] plaintext) throws
            NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException,
            BadPaddingException, IllegalBlockSizeException, IOException {
        final Cipher sm2Cipher = Cipher.getInstance("SM2", "BC");
        sm2Cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        // By default, Bouncy Castle returns raw ciphertext in the c1c2c3 format
        final byte [] cipherText = sm2Cipher.doFinal(plaintext);

        // Convert the raw ciphertext to the ASN.1 format before passing it to AWS KMS
        final ASN1EncodableVector asn1EncodableVector = new ASN1EncodableVector();
        final int coordinateLength = (SM2_X9EC_PARAMETERS.getCurve().getFieldSize() + 7) / 8 * 2 + 1;
        final int sm3HashLength = 32;
        final int xCoordinateInCipherText = 33;
        final int yCoordinateInCipherText = 65;
        byte[] coords = new byte[coordinateLength];
        byte[] sm3Hash = new byte[sm3HashLength];
        byte[] remainingCipherText = new byte[cipherText.length - coordinateLength - sm3HashLength];

        // Split components out of the ciphertext
        System.arraycopy(cipherText, 0, coords, 0, coordinateLength);
        System.arraycopy(cipherText, cipherText.length - sm3HashLength, sm3Hash, 0, sm3HashLength);
        System.arraycopy(cipherText, coordinateLength, remainingCipherText, 0,cipherText.length - coordinateLength - sm3HashLength);

        // Build standard SM2PKE ASN.1 ciphertext vector
        asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, 1, xCoordinateInCipherText))));
        asn1EncodableVector.add(new ASN1Integer(new BigInteger(1, Arrays.copyOfRange(coords, xCoordinateInCipherText, yCoordinateInCipherText))));
        asn1EncodableVector.add(new DEROctetString(sm3Hash));
        asn1EncodableVector.add(new DEROctetString(remainingCipherText));

        return new DERSequence(asn1EncodableVector).getEncoded("DER");
    }
}

Especificação da chave SYMMETRIC_DEFAULT

A especificação de chave padrão, SYMMETRIC_DEFAULT, é a especificação de chave para chaves do KMS de criptografia simétrica. Ao selecionar o tipo de chave Symmetric (Simétrica) e o uso de chave Encrypt and decrypt (Criptografar e descriptografar) no console do AWS KMS, ele seleciona a especificação de chave SYMMETRIC_DEFAULT. Na CreateKeyoperação, se você não especificar um KeySpec valor, SYMMETRIC_DEFAULT será selecionado. Se você não tiver um motivo para usar uma especificação de chave diferente, SYMMETRIC_DEFAULT é uma boa escolha.

SYMMETRIC_DEFAULT atualmente representa AES-256-GCM, um algoritmo simétrico baseado no on Advanced Encryption Standard (AES) em Galois Counter Mode (GCM) com chaves de 256 bits, um padrão do setor para criptografia segura. O texto cifrado que esse algoritmo gera oferece suporte a dados adicionais autenticados (ADD), como um contexto de criptografia e o GCM fornece uma verificação de integridade adicional no texto cifrado. Para obter mais detalhes técnicos, consulte Detalhes criptográficos para AWS Key Management Service.

Os dados criptografados em AES-256-GCM está protegido agora e futuramente. Os criptógrafos consideram esse algoritmo como resistente a quânticos. Num futuro teórico, ataques de computação quântica em grande escala em textos cifrados criados sob chaves AES-GCM de 256 bits reduzem a segurança efetiva da chave para 128 bits. No entanto, esse nível de segurança é suficiente para tornar inviáveis ataques de força bruta contra textos cifrados do AWS KMS.

A única exceção é aplicável às regiões da China, em que SYMMETRIC_DEFAULT representa uma chave simétrica de 128 bits que usa a criptografia SM4. Apenas é possível criar uma chave SM4 de 128 bits nas regiões da China. Uma chave do KMS AES-GCM de 256 bits não pode ser criada nas regiões da China.

É possível usar uma chave do KMS de criptografia simétrica no AWS KMS para criptografar, descriptografar e recriptografar dados, bem como para proteger as chaves de dados geradas e os pares de chaves de dados. Os serviços da AWS integrados ao AWS KMS usam chaves do KMS de criptografia simétrica para criptografar seus dados em repouso. Você pode importar seu próprio material de chave para uma chave do KMS de criptografia simétrica e criar chaves do KMS de criptografia simétrica em armazenamentos personalizados de chaves. Para acessar uma tabela comparando as operações que podem ser executadas em chaves do KMS simétricas e assimétricas, consulte Comparar chaves do KMS simétricas e assimétricas.

Para obter detalhes técnicos sobre o AWS KMS e chaves de criptografia simétrica, consulte Detalhes criptográficos do AWS Key Management Service.