本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

非对称密钥规范

以下主题提供了有关 AWS KMS 为非对称 KMS 密钥支持的密钥规范的技术信息。包括有关对称加密密钥的 SYMMETRIC_DEFAULT 密钥规范的信息以便进行比较。

RSA 密钥规范

使用 RSA 密钥规范时， AWS KMS 会创建一个带有 RSA 密钥对的非对称 KMS 密钥。私钥永远不会处于 AWS KMS 未加密状态。你可以在里面使用公钥 AWS KMS，也可以下载公钥在外面使用 AWS KMS。

在中 AWS KMS，您可以使用带有 RSA 密钥对的非对称 KMS 密钥进行加密和解密，或者签名和验证，但不能两者兼而有之。此属性（称为 密钥用法）与密钥规范分开确定，但应该在选择密钥规范之前做出决定。

AWS KMS 支持以下用于加密和解密或签名和验证的 RSA 密钥规范：

RSA 密钥规范因 RSA 密钥长度（以位为单位）而异。选择哪个 RSA 密钥规范可能取决于安全标准或任务要求。一般来说，可使用对任务而言实用又实惠的最大密钥。KMS 密钥加密操作的 RSA 密钥规范不同，其价格也不同。有关 AWS KMS 定价的信息，请参阅AWS 密钥管理服务定价。有关请求配额的信息，请参阅 请求配额。

用于加密和解密的 RSA 密钥规范

使用 RSA 非对称 KMS 密钥行加密和解密时，用公有密钥加密，然后用私有密钥解密。当您调用 RSA KMS 密钥的Encrypt操作时，会 AWS KMS 使用 RSA 密钥对中的公钥和您指定的加密算法来加密您的数据。 AWS KMS 要解密密文，请调用Decrypt操作并指定相同的 KMS 密钥和加密算法。 AWS KMS 然后使用 RSA key pair 中的私钥来解密您的数据。

您也可以下载公钥并使用它来加密外部的数据 AWS KMS。请务必使用 AWS KMS 支持 RSA KMS 密钥的加密算法。要解密密文，请采用相同的 KMS 密钥和加密算法调用 Decrypt 函数。

AWS KMS 支持两种具有 RSA 密钥规格的 KMS 密钥加密算法。这些算法在 PKCS #1 2.2 版中定义，它们内部使用的哈希函数有所不同。在 AWS KMS中，RSAES_OAEP 算法始终使用相同的哈希函数实现哈希目的和掩码生成函数 (MGF1)。调用 Encrypt 和 Decrypt 操作时，需要指定加密算法。您可以为每个请求选择不同的算法。

无法将 KMS 密钥配置为使用特定的加密算法。但是，您可以使用 kms: EncryptionAlgorithm 策略条件来指定允许委托人使用 KMS 密钥的加密算法。

要获取 KMS 密钥的加密算法，请在 AWS KMS 控制台中查看 KMS 密钥的加密配置或使用DescribeKey操作。 AWS KMS 当您在 AWS KMS 控制台中或使用GetPublicKey操作下载公钥时，还会提供密钥规范和加密算法。

您可以根据可在每个请求中加密的明文数据的长度，选择 RSA 密钥规范。下表显示了在对 Encrypt 操作的单次调用中，可以加密的明文的最大长度（以字节为单位）。值因密钥规范和加密算法而异。为进行比较，使用对称加密 KMS 密钥一次最多可加密 4096 字节。

要计算这些算法的最大明文长度（以字节为单位），请使用以下公式：(key_size_in_bits / 8) - (2 * hash_length_in_bits/8) - 2。例如，对于具有 SHA-256 的 RSA_2048，最大明文长度为 (2048/8) - (2 * 256/8) -2 = 190 字节。

用于签名和验证的 RSA 密钥规范

使用 RSA 非对称 KMS 密钥进行签名和验证时，用私有密钥为消息生成签名，然后用公有密钥验证签名。

当您调用非对称 KMS 密钥的Sign操作时，会 AWS KMS 使用 RSA 密钥对中的私钥、消息和您指定的签名算法来生成签名。 AWS KMS 要验证签名，请调用 Verify 操作。指定签名，以及相同的 KMS 密钥、消息和签名算法。 AWS KMS 然后使用 RSA key pair 中的公钥来验证签名。您也可以下载公钥并使用它来验证外部的签名 AWS KMS。

AWS KMS 支持所有具有 RSA 密钥规范的 KMS 密钥的以下签名算法。在您调用 Sign 和 Verify 操作后，需要指定签名算法。您可以为每个请求选择不同的算法。使用 RSA 密钥对进行签名时，首选 RSASSA-PSS 算法。为了与现有应用程序兼容，我们包含了 RSASSA-PKCS1-v1_5 算法。

无法将 KMS 密钥配置为使用特定的签名算法。但是，您可以使用 kms: SigningAlgorithm 策略条件来指定允许委托人使用 KMS 密钥的签名算法。

要获取 KMS 密钥的签名算法，请在 AWS KMS 控制台中或使用DescribeKey操作查看 KMS 密钥的加密配置。 AWS KMS 当您在 AWS KMS 控制台中或使用GetPublicKey操作下载公钥时，还会提供密钥规范和签名算法。

椭圆曲线密钥规范

使用椭圆曲线 (ECC) 密钥规范时， AWS KMS 会创建一个带有 ECC 密钥对的非对称 KMS 密钥，用于签名和验证或派生共享密钥（但不能两者兼而有之）。生成签名或派生共享机密的私钥永远不会处于 AWS KMS 未加密状态。您可以使用公钥来验证内部的签名 AWS KMS，也可以下载公钥以在外部使用 AWS KMS。

AWS KMS 支持非对称 KMS 密钥的以下 ECC 密钥规范。

选择哪个 ECC 密钥规范可能取决于安全标准或任务要求。一般来说，可使用对任务而言实用又实惠的点最多的曲线。

如果您要创建非对称 KMS 密钥来派生共享密钥，请使用 NIST 推荐的椭圆曲线密钥规范之一。唯一支持的用于派生共享密钥的密钥协商算法是椭圆曲线密码学辅助因子 Diffie-Hellman Primitive (ECDH)。

如果您正在创建非对称 KMS 密钥以用于加密货币，请使用 ECC_SEG_P256K1 密钥规范。此密钥规范也可以用于其他目的，但比特币和其他加密货币必须使用此密钥规范。

使用不同 ECC 密钥规范的 KMS 密钥定价不同，并受不同的请求配额限制。有关 AWS KMS 定价的信息，请参阅AWS Key Management Service 定价。有关请求配额的信息，请参阅 请求配额。

下表显示了每个 ECC 密钥规范 AWS KMS 支持的签名算法。无法将 KMS 密钥配置为使用特定的签名算法。但是，您可以使用 kms: SigningAlgorithm 策略条件来指定允许委托人使用 KMS 密钥的签名算法。

离线获取共享密钥

您可以下载 ECC key pair 的公钥以用于离线操作，即外部的 AWS KMS操作。

以下 OpenSSL 演练演示了一种在使用 ECC KMS 密钥对的公钥和 AWS KMS 使用 OpenSSL 创建的私钥之外获取共享密钥的方法。

SM2 密钥规范（仅限中国区域）

SM2 密钥规范是在 GM/T 系列规范中定义的椭圆曲线密钥规范，这一系列规范由中国国家商用密码管理办公室（OSCCA）发布。SM2 密钥规范仅限中国区域使用。使用 SM2 密钥规范时， AWS KMS 会创建一个带有 SM2 密钥对的非对称 KMS 密钥。你可以在里面使用你的 SM2 密钥对 AWS KMS，也可以下载公钥在外面使用。 AWS KMS

每个 KMS 密钥都只能有一个密钥用法。您可以使用 SM2 KMS 密钥进行签名和验证、加密和解密或获取共享密钥。在创建 KMS 密钥时，您必须指定密钥用途，并且密钥一经创建便无法更改。

如果您要创建非对称 KMS 密钥来派生共享密钥，请使用 SM2 密钥规范。唯一支持的用于派生共享密钥的密钥协商算法是椭圆曲线密码学辅助因子 Diffie-Hellman Primitive (ECDH)。

AWS KMS 支持以下 SM2 加密和签名算法：

借助 SM2 进行离线操作（仅限中国区域）

您可以下载 SM2 密钥对的公有密钥以在离线操作中使用，即 AWS KMS外部的操作。但是，离线使用 SM2 公有密钥时，您可能需要手动执行额外的转换和计算。SM2DSA 操作可能需要您提供区分 ID 或计算消息摘要。SM2PKE 加密操作可能需要您将原始密文输出转换为 AWS KMS 可以接受的格式。

为了帮助您使用这些操作，Java 的 SM2OfflineOperationHelper 类为您执行任务提供了方法。您可以将此帮助程序类用作其他加密提供程序的模型。

使用 SM2 密钥对进行离线验证（仅限中国区域）

要 AWS KMS 使用 SM2 公钥验证外部的签名，必须指定区分 ID。当你将原始消息传递给 S ign API 时 MessageType:RAW，会 AWS KMS 使用默认的区分 ID，该标识由 OSCCA 在 GM/T 0009-2012 中定义。1234567812345678您不能在 AWS KMS中指定自己的区分 ID。

但是，如果您要在外部生成消息摘要 AWS，则可以指定自己的区分 ID，然后将消息摘要传递 AWS KMS 给签名。MessageType:DIGEST要执行此操作，请更改 SM2OfflineOperationHelper 类中的 DEFAULT_DISTINGUISHING_ID 值。您指定的区分 ID 可以是长度不超过 8192 个字符的任何字符串。对消息摘要进行 AWS KMS 签名后，您需要消息摘要或消息以及用于计算摘要的区分 ID 以进行离线验证。

SM2OfflineOperationHelper 类

在内部 AWS KMS，原始密文转换和 SM2DSA 消息摘要计算会自动进行。并非所有加密提供程序都按相同的方式实现 SM2。某些库（例如 OpenSSL 版本 1.1.1 及更高版本）会自动执行这些操作。 AWS KMS 在 OpenSSL 版本 3.0 的测试中确认了这种行为。使用以下带有库的 SM2OfflineOperationHelper 类，比如 Bouncy Castle，这需要您手动执行这些转换和计算。

SM2OfflineOperationHelper 类为以下离线操作提供了方法：

默认情况下，在为 SM2DSA 操作生成消息摘要时，SM2OfflineOperationHelper 类使用默认的区分 ID 1234567812345678。

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");
    }
}

SYMMETRIC_DEFAULT 密钥规范

默认密钥规范 SYMMETRIC_DEFAULT 是对称加密 KMS 密钥的密钥规范。当您在 AWS KMS 控制台中选择 Symmetric 密钥类型以及加密和解密密钥用法时，它会选择密钥规范。SYMMETRIC_DEFAULT在CreateKey操作中，如果您未指定KeySpec值，则会选择 SYMMETRIC_DEFAULT。如果您没有理由使用其他密钥规范，SymMETIC_DEFAULT 是个不错的选择。

SYMMETRIC_DEFAULT 目前代表 AES-256-GCM，这是一种基于伽罗瓦计数器模式 (GCM) 中的高级加密标准 (AES) 的对称算法，具有 256 位密钥，是用于安全加密的行业标准。此算法生成的密文支持附加身份验证数据 (AAD)，如加密上下文，且 GCM 对密文提供额外的完整性检查。有关技术详细信息，请参阅 AWS Key Management Service 加密详细信息。

在 AES-256-GCM 下加密的数据现在和将来都受到保护。密码学家认为这种算法具备抗量子性。理论上，在未来针对使用 256 位 AES-GCM 密钥创建的密文的大规模量子计算攻击中，密钥的有效安全性将会降至 128 位。但是，这种安全级别足以使对 AWS KMS 密文的暴力攻击变得不可行。

唯一的例外是，在中国区域 SYMMETRIC_DEFAULT 表示使用 SM4 加密的 128 位对称密钥。您只能在中国区域内创建 128 位的 SM4 密钥。您无法在中国区域内创建 256 位的 AES-GCM KMS 密钥。

您可以使用中的对称加密 KMS 密钥 AWS KMS 来加密、解密和重新加密数据，以及保护生成的数据密钥和数据密钥对。 AWS 与之集成的服务 AWS KMS 使用对称加密 KMS 密钥对您的静态数据进行加密。您可以将自己的密钥材料导入对称加密 KMS 密钥中，并在自定义密钥存储中创建对称加密 KMS 密钥。有关可以对对称 KMS 密钥和非对称 KMS 密钥执行的操作的比较表格，请参阅比较对称 KMS 密钥与非对称 KMS 密钥。

有关 AWS KMS 对称加密密钥的技术细节，请参阅AWS Key Management Service 加密详细信息。