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 você usa uma especificação de chave RSA, AWS KMS cria uma chave KMS assimétrica com um par de chaves RSA. A chave privada nunca sai AWS KMS sem criptografia. Você pode usar a chave pública dentro AWS KMS ou baixar a chave pública para uso externo AWS KMS.

Atenção

Ao criptografar dados fora de AWS KMS, certifique-se de poder descriptografar seu 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.

Em AWS KMS, você pode usar chaves KMS assimétricas com pares de chaves RSA para criptografia e descriptografia, ou assinatura e verificação, mas não ambas. 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.

AWS KMS suporta as seguintes especificações de chave RSA para criptografia e decodificação ou 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 AWS KMS preços, consulte AWS Key Management Service Pricing. 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 você chama a Encrypt operação AWS KMS para obter uma chave RSA KMS, AWS KMS usa a chave pública no par de chaves RSA e o algoritmo de criptografia que você especifica para criptografar seus dados. Para descriptografar o texto cifrado, chame a Decrypt operação e especifique a mesma chave KMS e algoritmo de criptografia. AWS KMS em seguida, usa a chave privada no par de chaves RSA para descriptografar seus dados.

Você também pode baixar a chave pública e usá-la para criptografar dados externos. AWS KMS Certifique-se de usar um algoritmo de criptografia AWS KMS compatível com chaves RSA KMS. Para descriptografar o texto cifrado, chame a função Decrypt com a mesma chave do KMS e o mesmo algoritmo de criptografia.

AWS KMS suporta dois algoritmos de criptografia para chaves 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 KMS também fornece a especificação da chave e os algoritmos de criptografia quando você baixa sua chave pública, 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 Sign operação de uma chave KMS assimétrica, AWS KMS usa a chave privada no par de chaves RSA, a mensagem e o algoritmo de assinatura que você especifica para gerar uma assinatura. AWS KMS Para verificar a assinatura, chame a operação Verify. Especifique a assinatura, além da mesma chave KMS, mensagem e algoritmo de assinatura. AWS KMS em seguida, usa a chave pública no par de chaves RSA para verificar a assinatura. Você também pode baixar a chave pública e usá-la para verificar a assinatura fora do AWS KMS.

AWS KMS suporta os seguintes algoritmos de assinatura para todas as chaves 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 KMS també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 você usa uma especificação de chave de curva elíptica (ECC), AWS KMS cria uma chave KMS assimétrica com um par de chaves ECC para assinatura e verificação ou derivação de segredos compartilhados (mas não ambos). A chave privada que gera assinaturas ou deriva segredos compartilhados nunca sai sem criptografia. AWS KMS Você pode usar a chave pública para verificar as assinaturas dentro AWS KMS ou fazer o download da chave pública para uso AWS KMS externo.

AWS KMS suporta as seguintes especificações de chave ECC para chaves KMS assimétricas.

• Pares de chaves de curva elíptica assimétrica recomendados pelo NIST (assinatura e verificação ou derivação de segredos compartilhados)

  • 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 KMS assimétrica para derivar segredos compartilhados, use uma das principais especificações de curva elíptica recomendadas pelo NIST. O único algoritmo de concordância de chave compatível para derivar segredos compartilhados é o Eliptic Curve Cryptography Cofactor Diffie-Hellman Primitive (ECDH).

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 informações sobre AWS KMS preços, consulte AWS Key Management Service Preços. Para obter mais informações sobre cotas de solicitações, consulte Cotas de solicitações.

A tabela a seguir mostra os algoritmos de assinatura AWS KMS compatíveis com cada uma das principais especificações do 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.

Derivando segredos compartilhados offline

Você pode baixar a chave pública do seu par de chaves ECC para uso em operações off-line, ou seja, operações fora da AWS KMS.

O seguinte passo a passo do OpenSSL demonstra um método de derivar um segredo compartilhado fora do uso da chave pública de um par AWS KMS de chaves ECC KMS e de uma chave privada criada com o OpenSSL.

1. Crie um par de chaves ECC no OpenSSL e prepare-o para uso com o. AWS KMS

   // Create an ECC key pair in OpenSSL and save the private key in openssl_ecc_key_priv.pem
   export OPENSSL_CURVE_NAME="P-256"
   export KMS_CURVE_NAME="ECC_NIST_P256"
   
   export OPENSSL_KEY1_PRIV_PEM="openssl_ecc_key1_priv.pem"
   openssl ecparam -name ${OPENSSL_CURVE_NAME} -genkey -out ${OPENSSL_KEY1_PRIV_PEM}                    
                       
   // Derive the public key from the private key                    
   export OPENSSL_KEY1_PUB_PEM="openssl_ecc_key1_pub.pem"
   openssl ec -in ${OPENSSL_KEY1_PRIV_PEM} -pubout -outform pem \
       -out ${OPENSSL_KEY1_PUB_PEM}                    
                       
   // View the PEM file containing the public key and extract the public key as a 
   // Base64 encoded string into OPENSSL_KEY1_PUB_BASE64 for use with AWS KMS
   export OPENSSL_KEY1_PUB_BASE64=`cat ${OPENSSL_KEY1_PUB_PEM} | \
       tee /dev/stderr | grep -v "PUBLIC KEY" | tr -d "\n"`

2. Crie um par de chaves de acordo de chave ECC AWS KMS e prepare-o para uso com o OpenSSL.

   // Create a KMS key on the same curve as the key pair from step 1 
   // with a key usage of KEY_AGREEMENT
   // Save its ARN in KMS_KEY1_ARN.
   export KMS_KEY1_ARN=`aws kms create-key --key-spec ${KMS_CURVE_NAME} \
       --key-usage KEY_AGREEMENT | tee /dev/stderr | jq -r .KeyMetadata.Arn`
   
   // Download the public key and save the Base64-encoded version in KMS_KEY1_PUB_BASE64        
   export KMS_KEY1_PUB_BASE64=`aws kms get-public-key --key-id ${KMS_KEY1_ARN} | \
       tee /dev/stderr | jq -r .PublicKey`                    
                       
   // Create a PEM file for the public KMS key for use with OpenSSL   
   export KMS_KEY1_PUB_PEM="aws_kms_ecdh_key1_pub.pem"
   echo "-----BEGIN PUBLIC KEY-----" > ${KMS_KEY1_PUB_PEM}
   echo ${KMS_KEY1_PUB_BASE64} | fold -w 64 >> ${KMS_KEY1_PUB_PEM}
   echo "-----END PUBLIC KEY-----" >> ${KMS_KEY1_PUB_PEM}

3. Derive o segredo compartilhado no OpenSSL usando a chave privada no OpenSSL e a chave pública do KMS.

   export OPENSSL_SHARED_SECRET1_BIN="openssl_shared_secret1.bin"
   openssl pkeyutl -derive -inkey ${OPENSSL_KEY1_PRIV_PEM} \
       -peerkey ${KMS_KEY1_PUB_PEM} -out ${OPENSSL_SHARED_SECRET1_BIN}

Mostrar maisMostrar menos

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 você usa a especificação de chave SM2, AWS KMS cria uma chave KMS assimétrica com um par de chaves SM2. Você pode usar seu par de chaves SM2 dentro AWS KMS ou baixar a chave pública para uso AWS KMS externo.

Cada chave do KMS pode ter apenas um uso de chave. Você pode usar uma chave SM2 KMS para assinatura e verificação, criptografia e decodificação ou derivação de segredos compartilhados. 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.

Se você estiver criando uma chave KMS assimétrica para derivar segredos compartilhados, use a especificação de chave SM2. O único algoritmo de concordância de chave compatível para derivar segredos compartilhados é o Eliptic Curve Cryptography Cofactor Diffie-Hellman Primitive (ECDH).

AWS KMS suporta 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 uma ID distintiva que seja codificada com o algoritmo de hash SM3 e depois combinada com a mensagem, ou resumo da mensagem, para a qual você passou. AWS KMS Esse valor concatenado é então codificado e assinado por. 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. As operações de criptografia do SM2PKE podem exigir que você converta a saída de texto cifrado bruto em um formato que possa aceitar. 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 externa AWS KMS com uma chave pública SM2, você deve especificar a ID distintiva. Quando você passa uma mensagem bruta, MessageType:RAW, para a API Sign, AWS KMS usa o ID distintivo padrão1234567812345678, definido pela OSCCA em GM/T 0009-2012. Você não pode especificar seu próprio ID de distinção no AWS KMS.

No entanto, se você estiver gerando um resumo da mensagem fora do AWS, poderá especificar seu próprio ID distintivo e, em seguida, passar o resumo da mensagem, MessageType:DIGEST, para 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 de AWS KMS assinar o resumo da mensagem, você precisa do resumo da mensagem ou da mensagem e do ID distintivo usado para computar o resumo para verificá-lo offline.

Classe SM2OfflineOperationHelper

No interior AWS KMS, as conversões de texto cifrado bruto e os cálculos de resumo de mensagens SM2DSA ocorrem automaticamente. Nem todos os provedores criptográficos implementam o SM2 da mesma maneira. Algumas bibliotecas, como as versões 1.1.1 e posteriores do OpenSSL, executam essas ações automaticamente. AWS KMS confirmou esse comportamento em testes com o 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 mensagens offline que você possa usar para verificação off-line ou que você possa passar AWS KMS para assinar, use o calculateSM2Digest método. 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. Esse método garante que o texto cifrado esteja em um formato que AWS KMS possa ser descriptografado. 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. Quando você seleciona o tipo de chave simétrica e o uso da chave de criptografia e descriptografia no AWS KMS console, ele seleciona a especificação da 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. Mas esse nível de segurança é suficiente para inviabilizar ataques de força bruta em textos AWS KMS cifrados.

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.

Você pode usar uma chave KMS de criptografia simétrica AWS KMS para criptografar, descriptografar e recriptografar dados e para proteger chaves de dados e pares de chaves de dados gerados. AWS os serviços integrados AWS KMS usam chaves 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 AWS KMS e chaves de criptografia simétricas, consulte Detalhes AWS Key Management Service criptográficos.