Uso de Verify con un SDK de AWS o la CLI

Cómo verificar una firma digital

En el siguiente ejemplo de verify, se verifica una firma criptográfica para un mensaje corto codificado en Base64. El identificador de clave, el mensaje, el tipo de mensaje y el algoritmo de firma deben ser los mismos que se usaron para firmar el mensaje.

En la CLI v2 de AWS, el valor del parámetro message debe estar codificado en Base64. O bien, puede guardar el mensaje en un archivo y usar el prefijo fileb://, que indica a la CLI de AWS que lea los datos binarios del archivo.

La firma que especifique no puede estar codificada en base64. Para obtener ayuda para decodificar la firma que devuelve el comando sign, consulte los ejemplos de comandos sign.

El resultado del comando incluye un campo SignatureValid booleano que indica que se verificó la firma. Si se produce un error en la validación de la firma, también se produce un error en el comando verify.

Antes de ejecutar este comando, reemplace el ID de clave de ejemplo por uno válido de su cuenta de AWS.

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

Salida:

{
    "KeyId": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    "SignatureValid": true,
    "SigningAlgorithm": "RSASSA_PKCS1_V1_5_SHA_256"
}

Para obtener más información sobre el uso de claves KMS asimétricas en AWS KMS, consulte Uso de claves simétricas y asimétricas en la AWSGuía para desarrolladores de Key Management Service.

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 verify(self, key_id: str, message: str, signature: str) -> bool:
        """
        Verifies a signature against a message.

        :param key_id: The ARN or ID of the key used to sign the message.
        :param message: The message to verify.
        :param signature: The signature to verify.
        :return: True when the signature matches the message, otherwise False.
        """
        try:
            response = self.kms_client.verify(
                KeyId=key_id,
                Message=message.encode(),
                Signature=signature,
                SigningAlgorithm="RSASSA_PSS_SHA_256",
            )
            valid = response["SignatureValid"]
            print(f"The signature is {'valid' if valid else 'invalid'}.")
            return valid
        except ClientError as err:
            if err.response["Error"]["Code"] == "SignatureDoesNotMatchException":
                print("The signature is not valid.")
            else:
                logger.error(
                    "Couldn't verify your signature. Here's why: %s",
                    err.response["Error"]["Message"],
                )
            raise