Gunakan Sign dengan AWS SDK atau CLI

Contoh 1: Untuk menghasilkan tanda tangan digital untuk pesan

signContoh berikut menghasilkan tanda tangan kriptografi untuk pesan singkat. Output dari perintah mencakup Signature bidang yang dikodekan basis-64 yang dapat Anda verifikasi dengan menggunakan perintah. verify

Anda harus menentukan pesan yang akan ditandatangani dan algoritma penandatanganan yang didukung oleh KMS kunci asimetris Anda. Untuk mendapatkan algoritma penandatanganan untuk KMS kunci Anda, gunakan describe-key perintah.

Di AWS CLI 2.0, nilai message parameter harus dikodekan Base64. Atau, Anda dapat menyimpan pesan dalam file dan menggunakan fileb:// awalan, yang memberitahu AWS CLI untuk membaca data biner dari file.

Sebelum menjalankan perintah ini, ganti ID kunci contoh dengan ID kunci yang valid dari AWS akun Anda. ID kunci harus mewakili KMS kunci asimetris dengan penggunaan kunci SIGN _VERIFY.

msg=(echo 'Hello World' | base64)

aws kms sign \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://UnsignedMessage \
    --message-type RAW \
    --signing-algorithm RSASSA_PKCS1_V1_5_SHA_256

Output:

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "Signature": "ABCDEFhpyVYyTxbafE74ccSvEJLJr3zuoV1Hfymz4qv+/fxmxNLA7SE1SiF8lHw80fKZZ3bJ...",
    "SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}

Untuk informasi selengkapnya tentang penggunaan KMS kunci asimetris AWS KMS, lihat Kunci asimetris AWS KMS di Panduan Pengembang Layanan Manajemen AWS Kunci.

Contoh 2: Untuk menyimpan tanda tangan digital dalam file (Linux danmacOs)

signContoh berikut menghasilkan tanda tangan kriptografi untuk pesan singkat yang disimpan dalam file lokal. Perintah juga mendapatkan Signature properti dari respons, Base64-mendekodekannya dan menyimpannya dalam file. ExampleSignature Anda dapat menggunakan file tanda tangan dalam verify perintah yang memverifikasi tanda tangan.

signPerintah ini memerlukan pesan yang disandikan Base64 dan algoritme penandatanganan yang didukung oleh kunci asimetris Anda. KMS Untuk mendapatkan algoritma penandatanganan yang didukung KMS kunci Anda, gunakan describe-key perintah.

Sebelum menjalankan perintah ini, ganti ID kunci contoh dengan ID kunci yang valid dari AWS akun Anda. ID kunci harus mewakili KMS kunci asimetris dengan penggunaan kunci SIGN _VERIFY.

echo 'hello world' | base64 > EncodedMessage

aws kms sign \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --message fileb://EncodedMessage \
    --message-type RAW \
    --signing-algorithm RSASSA_PKCS1_V1_5_SHA_256 \
    --output text \
    --query Signature | base64 --decode > ExampleSignature

Perintah ini tidak menghasilkan output. Contoh ini mengekstrak Signature properti output dan menyimpannya dalam file.

Untuk informasi selengkapnya tentang penggunaan KMS kunci asimetris AWS KMS, lihat Kunci asimetris AWS KMS di Panduan Pengembang Layanan Manajemen AWS Kunci.

    /**
     * Asynchronously signs and verifies data using AWS KMS.
     *
     * <p>The method performs the following steps:
     * <ol>
     *     <li>Creates an AWS KMS key with the specified key spec, key usage, and origin.</li>
     *     <li>Signs the provided message using the created KMS key and the RSASSA-PSS-SHA-256 algorithm.</li>
     *     <li>Verifies the signature of the message using the created KMS key and the RSASSA-PSS-SHA-256 algorithm.</li>
     * </ol>
     *
     * @return a {@link CompletableFuture} that completes with the result of the signature verification,
     *         {@code true} if the signature is valid, {@code false} otherwise.
     * @throws KmsException if any error occurs during the KMS operations.
     * @throws RuntimeException if an unexpected error occurs.
     */
    public CompletableFuture<Boolean> signVerifyDataAsync() {
        String signMessage = "Here is the message that will be digitally signed";

        // Create an AWS KMS key used to digitally sign data.
        CreateKeyRequest createKeyRequest = CreateKeyRequest.builder()
            .keySpec(KeySpec.RSA_2048)
            .keyUsage(KeyUsageType.SIGN_VERIFY)
            .origin(OriginType.AWS_KMS)
            .build();

        return getAsyncClient().createKey(createKeyRequest)
            .thenCompose(createKeyResponse -> {
                String keyId = createKeyResponse.keyMetadata().keyId();

                SdkBytes messageBytes = SdkBytes.fromString(signMessage, Charset.defaultCharset());
                SignRequest signRequest = SignRequest.builder()
                    .keyId(keyId)
                    .message(messageBytes)
                    .signingAlgorithm(SigningAlgorithmSpec.RSASSA_PSS_SHA_256)
                    .build();

                return getAsyncClient().sign(signRequest)
                    .thenCompose(signResponse -> {
                        byte[] signedBytes = signResponse.signature().asByteArray();

                        VerifyRequest verifyRequest = VerifyRequest.builder()
                            .keyId(keyId)
                            .message(SdkBytes.fromByteArray(signMessage.getBytes(Charset.defaultCharset())))
                            .signature(SdkBytes.fromByteBuffer(ByteBuffer.wrap(signedBytes)))
                            .signingAlgorithm(SigningAlgorithmSpec.RSASSA_PSS_SHA_256)
                            .build();

                        return getAsyncClient().verify(verifyRequest)
                            .thenApply(verifyResponse -> {
                                return (boolean) verifyResponse.signatureValid();
                            });
                    });
            })
            .exceptionally(throwable -> {
               throw new RuntimeException("Failed to sign or verify data", throwable);
            });
    }

    /***
     * @param string $keyId
     * @param string $message
     * @param string $algorithm
     * @return Result
     */
    public function sign(string $keyId, string $message, string $algorithm)
    {
        try {
            return $this->client->sign([
                'KeyId' => $keyId,
                'Message' => $message,
                'SigningAlgorithm' => $algorithm,
            ]);
        }catch(KmsException $caught){
            echo "There was a problem signing the data: {$caught->getAwsErrorMessage()}\n";
            throw $caught;
        }
    }

class KeyEncrypt:
    def __init__(self, kms_client):
        self.kms_client = kms_client

    @classmethod
    def from_client(cls) -> "KeyEncrypt":
        """
        Creates a KeyEncrypt instance with a default KMS client.

        :return: An instance of KeyEncrypt initialized with the default KMS client.
        """
        kms_client = boto3.client("kms")
        return cls(kms_client)


    def sign(self, key_id: str, message: str) -> str:
        """
        Signs a message with a key.

        :param key_id: The ARN or ID of the key to use for signing.
        :param message: The message to sign.
        :return: The signature of the message.
        """
        try:
            return self.kms_client.sign(
                KeyId=key_id,
                Message=message.encode(),
                SigningAlgorithm="RSASSA_PSS_SHA_256",
            )["Signature"]
        except ClientError as err:
            logger.error(
                "Couldn't sign your message. Here's why: %s",
                err.response["Error"]["Message"],
            )
            raise