Utilisation de Sign avec un kit AWS SDK ou une interface de ligne de commande

Les exemples de code suivants illustrent comment utiliser Sign.

Les exemples d’actions sont des extraits de code de programmes de plus grande envergure et doivent être exécutés en contexte. Vous pouvez voir cette action en contexte dans l’exemple de code suivant :

• Découverte des principes de base

CLI

AWS CLI

Exemple 1 : pour générer une signature numérique pour un message

L’exemple sign suivant génère une signature cryptographique pour un message court. La sortie de la commande inclut un champ Signature encodé en base-64 que vous pouvez vérifier à l’aide de la commande verify.

Vous devez spécifier un message à signer et un algorithme de signature pris en charge par votre clé KMS asymétrique. Pour obtenir les algorithmes pour votre clé KMS, utilisez la commande describe-key.

Dans l’interface de ligne de commande (CLI) AWS v2, la valeur du paramètre message doit être encodée en Base64. Vous pouvez également enregistrer le message dans un fichier et utiliser le préfixe fileb://, qui indique à l’interface de ligne de commande (CLI) AWS de lire les données binaires du fichier.

Avant d’exécuter cette commande, remplacez l’exemple d’ID de clé par un ID de clé valide provenant de votre compte AWS. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est 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

Sortie :

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

Pour plus d’informations sur l’utilisation des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Guide du développeur AWS Key Management Service.

Exemple 2 : pour enregistrer une signature numérique dans un fichier (Linux et macOS)

L’exemple sign suivant génère une signature cryptographique pour un message court stocké dans un fichier local. La commande extrait également la propriété Signature de la réponse, la décode en Base64 et l’enregistre dans le fichier ExampleSignature. Vous pouvez utiliser le fichier de signature dans une commande verify qui vérifie la signature.

La commande sign nécessite un message encodé en Base64 et un algorithme de signature pris en charge par votre clé KMS asymétrique. Pour obtenir les algorithmes de signature pris en charge par votre clé KMS, utilisez la commande describe-key.

Avant d’exécuter cette commande, remplacez l’exemple d’ID de clé par un ID de clé valide provenant de votre compte AWS. L’ID de clé doit représenter une clé KMS asymétrique dont l’utilisation est 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

Cette commande ne produit aucun résultat. Cet exemple extrait la propriété Signature de la sortie et l’enregistre dans un fichier.

Pour plus d’informations sur l’utilisation des clés KMS asymétriques dans AWS KMS, consultez Clés asymétriques dans AWS KMS dans le Guide du développeur AWS Key Management Service.

• Pour plus de détails sur l’API, consultez Sign dans la Référence des commandes de l’AWS CLI.

Java

SDK pour Java 2.x

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples de code AWS.

    /**
     * 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);
            });
    }

• Pour plus de détails sur l’API, consultez Sign dans la Référence des API du kit AWS SDK for Java 2.x.

PHP

Kit SDK pour PHP

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples de code AWS.

    /***
     * @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;
        }
    }

• Pour plus de détails sur l’API, consultez Sign dans la Référence des API du kit AWS SDK pour PHP.

Python

Kit SDK pour Python (Boto3)

Note

Il y en a plus sur GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le référentiel d’exemples de code AWS.

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

• Pour plus de détails sur l’API, consultez Sign dans la Référence des API du kit AWS SDK for Python (Boto3).