本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

非對稱金鑰規格

下列主題提供有關金鑰規格的技術資訊，這些都是 AWS KMS 支援的非對稱 KMS 金鑰規格。其中包括對稱加密金鑰的 SYMMETRIC_DEFAULT 金鑰規格資訊，以供比較之用。

RSA 金鑰規格

使用 RSA 金鑰規格時， AWS KMS 會建立具有 RSA key pair 的非對稱 KMS 金鑰。私密金鑰永遠不會離開 AWS KMS 未加密。您可以在其中使用公鑰 AWS KMS，也可以下載公鑰以供外部使用 AWS KMS。

在中 AWS KMS，您可以將非對稱 KMS 金鑰與 RSA 金鑰配對搭配使用，進行加密和解密，或簽署和驗證，但不能同時使用兩者。此屬性稱為「金鑰用途」，與金鑰規格分開決定，但應該在選取金鑰規格前決定。

AWS KMS 支援下列 RSA 金鑰規格，以進行加密和解密，或簽署和驗證：

RSA 金鑰規格因 RSA 金鑰的位元長度而不同。您選擇的 RSA 金鑰規格可能隨安全標準或任務需求而定。任務一般會使用實用且可負擔的最長密鑰。具有不同 RSA 金鑰規格之 KMS 金鑰的密碼編譯操作定價也不同。如需 AWS KMS 定價的相關資訊，請參閱AWS 金鑰管理服務定價。如需請求配額的詳細資訊，請參閱 請求配額。

用於加密和解密的 RSA 金鑰規格

使用 RSA 非對稱 KMS 金鑰加密和解密時，您會使用公有金鑰加密，並使用私有金鑰解密。當您 AWS KMS 針對 RSA KMS 金鑰呼叫Encrypt作業時， AWS KMS 會使用 RSA key pair 中的公開金鑰和您指定的加密演算法來加密資料。若要解密密文，請呼叫Decrypt作業並指定相同的 KMS 金鑰和加密演算法。 AWS KMS 然後使用 RSA 密鑰對中的私 key pair 來解密您的數據。

您也可以下載公開金鑰，並使用它來加密外部的資料 AWS KMS。請務必使用 AWS KMS 支援 RSA KMS 金鑰的加密演算法。若要解密加密文字，請使用相同的 KMS 金鑰和加密演算法呼叫 Decrypt 函數。

AWS KMS 支援兩種具有 RSA 金鑰規格的 KMS 金鑰加密演算法。這些演算法同在 PKCS #1 v2.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 金鑰執行簽署和驗證作業時，您會使用私有金鑰產生訊息的簽章，並使用公有金鑰驗證該簽章。

當您 AWS KMS 針對非對稱 KMS 金鑰呼叫Sign作業時， AWS KMS 會使用 RSA key pair 中的私密金鑰、訊息以及您指定的簽章演算法來產生簽章。若要驗證簽章，請呼叫 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 key pair 的非對稱 KMS 金鑰，以便簽署和驗證或衍生共用密碼 (但不能同時使用兩者)。生成簽名或導出共享密鑰的私鑰永遠不會保留 AWS KMS 未加密。您可以使用公開金鑰驗證其中的簽名 AWS KMS，或下載公開金鑰以供在其他地方使用 AWS KMS。

AWS KMS 支援下列非對稱 KMS 金鑰的 ECC 金鑰規格。

您選擇的 ECC 金鑰規格可能隨安全標準或任務需求而定。任務一般會使用實用且可負擔的最多點曲線。

如果您要建立非對稱 KMS 金鑰來衍生共用密碼，請使用 NIST 建議的橢圓曲線金鑰規格之一。導出共享密鑰的唯一支持的密鑰協議算法是橢圓曲線密碼學輔因子迪菲-赫爾曼原始（ECDH）。

如果您要建立非對稱 KMS 金鑰以搭配使用加密貨幣，請使用 ECC_SECG_P256K1 金鑰規格。此金鑰規格也可供其他用途使用，但對 Bitcoin 和其他加密貨幣而言是必要項目。

具有不同 ECC 金鑰規格的 KMS 金鑰定價也不同，而且有不同的請求配額。如需 AWS KMS 定價的相關資訊，請參閱AWS Key Management Service 定價。如需請求配額的詳細資訊，請參閱 請求配額。

下表顯示 AWS KMS 支援每個 ECC 金鑰規格的簽章演算法。您無法將 KMS 金鑰設定為使用特定的簽署演算法。不過，您可以使用 kms: SigningAlgorithm 原則條件來指定允許主體搭配 KMS 金鑰使用的簽署演算法。

離線派生共享的秘密

您可以下載 ECC 金鑰組的公開 key pair，以便在離線作業中使用，也就是以外的 AWS KMS作業。

以下 OpenSSL 逐步解說將示範在使用 ECC KMS 金鑰組的公開金鑰和 AWS KMS 使用 OpenSSL 建立之私密金 key pair 之外衍生共用密鑰的一種方法。

SM2 金鑰規格 (僅限中國區域)

SM2 金鑰規格是在中國商用密碼管理辦公室 (OSCCA) 公佈的 GM/T 系列規格中定義的橢圓曲線金鑰規格。SM2 金鑰規格僅在中國區域提供。當您使用 SM2 金鑰規格時， AWS KMS 會建立具有 SM2 key pair 的非對稱 KMS 金鑰。您可以在其中使用 SM2 key pair AWS KMS，也可以下載公鑰以供外部 AWS KMS使用。

每個 KMS 金鑰都僅有一種金鑰用途。您可以使用 SM2 KMS 金鑰進行簽署和驗證、加密和解密，或衍生共用密碼。在建立 KMS 金鑰時，您必須指定金鑰使用方式，且在金鑰建立之後即無法變更。

如果您要建立非對稱 KMS 金鑰來衍生共用密碼，請使用 SM2 金鑰規格。導出共享密鑰的唯一支持的密鑰協議算法是橢圓曲線密碼學輔因子迪菲-赫爾曼原始（ECDH）。

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

使用 SM2 進行離線操作 (僅限中國區域)

您可以下載您 SM2 金鑰對的公有金鑰以進行離線操作，即在 AWS KMS的外部操作。但是，離線使用 SM2 公有金鑰時，您可能需要手動執行額外的轉換和計算。SM2DSA 操作可能會要求您提供辨別 ID 或計算訊息摘要。SM2PKE 加密操作可能會要求您將原始密文輸出轉換為 AWS KMS 可以接受的格式。

為了協助您進行這些操作，Java 的 SM2OfflineOperationHelper 類別具有為您執行任務的方法。您可以使用此輔助程式類別作為針對其他密碼提供者的模型。

使用 SM2 金鑰對進行離線驗證 (僅限中國區域)

若要 AWS KMS 使用 SM2 公開金鑰驗證以外的簽章，您必須指定辨別 ID。當您將原始訊息傳遞至簽署 API 時 MessageType:RAW， AWS KMS 會使用由 OCSCA 在 GM/T 0009-2012 中定義的預設辨別識別碼。1234567812345678您無法在 AWS KMS中指定自己的辦別 ID。

不過，如果您要在以外產生訊息摘要 AWS，您可以指定您自己的辨別 ID，然後將 AWS KMS 訊息摘要傳遞給簽署。MessageType:DIGEST若要執行此操作，請變更 SM2OfflineOperationHelper 類別中的 DEFAULT_DISTINGUISHING_ID 值。您指定的辨別 ID 可以是最長 8,192 個字元的任何字串。 AWS KMS 簽署訊息摘要之後，您需要訊息摘要或訊息，以及用來計算摘要的辨別 ID，以便離線驗證摘要。

SM2OfflineOperationHelper 類別

在中 AWS KMS，原始密文轉換和 SM2DSA 郵件摘要計算會自動進行。並非所有加密提供者都以相同的方式實施 SM2。某些程式庫 (例如 OpenSSL 1.1.1 及更新版本) 會自動執行這些動作。 AWS KMS 在使用 3.0 版進行測試時確認 OpenSSL 這種行為。使用以下 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_DEFAULT鑰規格。在CreateKey作業中，如果您未指定KeySpec值，則會選取「對稱 _ 預設值」。如果沒有使用不同金鑰規格的理由，SYMMETRIC_DEFAULT 是很好的選擇。

SYMMETRIC_DEFAULT 目前表示 AES-256-GCM，一種基於具有 256 位元金鑰之 Galois 計數器模式 (GCM) 中的進階加密標準 (AES) 的對稱演算法，是安全加密的業界標準。此演算法產生的加密文字支援額外的驗證資料 (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 金鑰。

如需有關 AWS KMS 和對稱加密金鑰的技術詳細資訊，請參閱AWS Key Management Service 密碼編譯詳細資料。