À utiliser Decrypt avec un AWS SDK ou CLI

Exemple 1 : pour déchiffrer un message chiffré avec une KMS clé symétrique (Linux et macOS)

L'exemple de decrypt commande suivant montre la méthode recommandée pour déchiffrer des données avec. AWS CLI Cette version montre comment déchiffrer des données sous une clé symétriqueKMS.

Fournissez le texte chiffré dans un fichier. Dans la valeur du --ciphertext-blob paramètre, utilisez le fileb:// préfixe, qui indique CLI à lire les données d'un fichier binaire. Si le fichier ne se trouve pas dans le répertoire actuel, saisissez le chemin complet du fichier. Pour plus d'informations sur la lecture des valeurs de AWS CLI paramètres d'un fichier, consultez la section Chargement de AWS CLI paramètres depuis un fichier < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> dans le guide de l'utilisateur de l'interface de ligne de AWS commande et les meilleures pratiques pour les paramètres de fichiers locaux < https://aws.amazon.com/blogs/ developer/ best-practices-for-local -file-parameters/> dans le blog des outils de ligne de AWS commande .Spécifiez la clé pour déchiffrer le texte chiffré. Le paramètre n'est pas obligatoire lors du déchiffrement avec une KMS clé symétrique. --key-id KMS AWS KMSpeut obtenir l'identifiant de la KMS clé qui a été utilisée pour chiffrer les données à partir des métadonnées du texte chiffré. Mais il est toujours recommandé de spécifier la KMS clé que vous utilisez. Cette pratique garantit que vous utilisez la KMS clé que vous souhaitez utiliser et vous empêche de déchiffrer par inadvertance un texte chiffré à l'aide d'une KMS clé à laquelle vous n'avez pas confiance. Demandez la sortie en texte brut sous forme de valeur de texte.Le --query paramètre indique au de n'obtenir que la valeur du champ à partir de la CLI sortie. Plaintext Le --output paramètre renvoie la sortie sous forme de texte.Base64 décodez le texte en clair et enregistrez-le dans un fichier. L'exemple suivant montre comment rediriger (|) la valeur du Plaintext paramètre vers l'utilitaire Base64, qui le décode. Ensuite, il redirige (>) la sortie décodée vers le ExamplePlaintext fichier.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.

aws kms decrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --output text \
    --query Plaintext | base64 \
    --decode > ExamplePlaintextFile

Cette commande ne produit aucun résultat. La sortie de la decrypt commande est décodée en base64 et enregistrée dans un fichier.

Pour plus d'informations, voir Déchiffrer dans le manuel de APIréférence du service de gestion des AWS clés.

Exemple 2 : pour déchiffrer un message chiffré avec une KMS clé symétrique (invite de commande Windows)

L'exemple suivant est identique au précédent, sauf qu'il utilise l'certutilutilitaire pour décoder les données en texte brut en Base64. Cette procédure nécessite deux commandes, comme indiqué dans les exemples suivants.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.

aws kms decrypt ^
    --ciphertext-blob fileb://ExampleEncryptedFile ^
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab ^
    --output text ^
    --query Plaintext > ExamplePlaintextFile.base64

Exécutez la commande certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Sortie :

Input Length = 18
Output Length = 12
CertUtil: -decode command completed successfully.

Pour plus d'informations, voir Déchiffrer dans le manuel de APIréférence du service de gestion des AWS clés.

Exemple 3 : Pour déchiffrer un message chiffré avec une KMS clé asymétrique (Linux et macOS)

L'exemple de decrypt commande suivant montre comment déchiffrer des données chiffrées sous une clé RSA asymétriqueKMS.

Lors de l'utilisation d'une KMS clé asymétrique, le encryption-algorithm paramètre, qui spécifie l'algorithme utilisé pour chiffrer le texte en clair, est obligatoire.

Avant d'exécuter cette commande, remplacez l'exemple d'ID de clé par un ID de clé valide provenant de votre AWS compte.

aws kms decrypt \
    --ciphertext-blob fileb://ExampleEncryptedFile \
    --key-id 0987dcba-09fe-87dc-65ba-ab0987654321 \
    --encryption-algorithm RSAES_OAEP_SHA_256 \
    --output text \
    --query Plaintext | base64 \
    --decode > ExamplePlaintextFile

Cette commande ne produit aucun résultat. La sortie de la decrypt commande est décodée en base64 et enregistrée dans un fichier.

Pour plus d'informations, consultez la section Clés asymétriques AWS KMS dans le Guide du développeur du service de gestion des AWS clés.

    /**
     * Asynchronously decrypts the given encrypted data using the specified key ID.
     *
     * @param encryptedData The encrypted data to be decrypted.
     * @param keyId The ID of the key to be used for decryption.
     * @return A CompletableFuture that, when completed, will contain the decrypted data as a String.
     *         If an error occurs during the decryption process, the CompletableFuture will complete
     *         exceptionally with the error, and the method will return an empty String.
     */
    public CompletableFuture<String> decryptDataAsync(SdkBytes encryptedData, String keyId) {
        DecryptRequest decryptRequest = DecryptRequest.builder()
            .ciphertextBlob(encryptedData)
            .keyId(keyId)
            .build();

        CompletableFuture<DecryptResponse> responseFuture = getAsyncClient().decrypt(decryptRequest);
        responseFuture.whenComplete((decryptResponse, exception) -> {
            if (exception == null) {
                logger.info("Data decrypted successfully for key ID: " + keyId);
            } else {
                if (exception instanceof KmsException kmsEx) {
                    throw new RuntimeException("KMS error occurred while decrypting data: " + kmsEx.getMessage(), kmsEx);
                } else {
                    throw new RuntimeException("An unexpected error occurred while decrypting data: " + exception.getMessage(), exception);
                }
            }
        });

        return responseFuture.thenApply(decryptResponse -> decryptResponse.plaintext().asString(StandardCharsets.UTF_8));
    }

suspend fun encryptData(keyIdValue: String): ByteArray? {
    val text = "This is the text to encrypt by using the AWS KMS Service"
    val myBytes: ByteArray = text.toByteArray()

    val encryptRequest =
        EncryptRequest {
            keyId = keyIdValue
            plaintext = myBytes
        }

    KmsClient { region = "us-west-2" }.use { kmsClient ->
        val response = kmsClient.encrypt(encryptRequest)
        val algorithm: String = response.encryptionAlgorithm.toString()
        println("The encryption algorithm is $algorithm")

        // Return the encrypted data.
        return response.ciphertextBlob
    }
}

suspend fun decryptData(
    encryptedDataVal: ByteArray?,
    keyIdVal: String?,
    path: String,
) {
    val decryptRequest =
        DecryptRequest {
            ciphertextBlob = encryptedDataVal
            keyId = keyIdVal
        }
    KmsClient { region = "us-west-2" }.use { kmsClient ->
        val decryptResponse = kmsClient.decrypt(decryptRequest)
        val myVal = decryptResponse.plaintext

        // Write the decrypted data to a file.
        if (myVal != null) {
            File(path).writeBytes(myVal)
        }
    }
}

    /***
     * @param string $keyId
     * @param string $ciphertext
     * @param string $algorithm
     * @return Result
     */
    public function decrypt(string $keyId, string $ciphertext, string $algorithm = "SYMMETRIC_DEFAULT")
    {
        try{
            return $this->client->decrypt([
                'CiphertextBlob' => $ciphertext,
                'EncryptionAlgorithm' => $algorithm,
                'KeyId' => $keyId,
            ]);
        }catch(KmsException $caught){
            echo "There was a problem decrypting 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 decrypt(self, key_id: str, cipher_text: str) -> bytes:
        """
        Decrypts text previously encrypted with a key.

        :param key_id: The ARN or ID of the key used to decrypt the data.
        :param cipher_text: The encrypted text to decrypt.
        :return: The decrypted text.
        """
        try:
            return self.kms_client.decrypt(KeyId=key_id, CiphertextBlob=cipher_text)[
                "Plaintext"
            ]
        except ClientError as err:
            logger.error(
                "Couldn't decrypt your ciphertext. Here's why: %s",
                err.response["Error"]["Message"],
            )
            raise

require 'aws-sdk-kms' # v2: require 'aws-sdk'

# Decrypted blob

blob = '01020200785d68faeec386af1057904926253051eb2919d3c16078badf65b808b26dd057c101747cadf3593596e093d4ffbf22434a6d00000068306606092a864886f70d010706a0593057020100305206092a864886f70d010701301e060960864801650304012e3011040c9d629e573683972cdb7d94b30201108025b20b060591b02ca0deb0fbdfc2f86c8bfcb265947739851ad56f3adce91eba87c59691a9a1'
blob_packed = [blob].pack('H*')

client = Aws::KMS::Client.new(region: 'us-west-2')

resp = client.decrypt({
                        ciphertext_blob: blob_packed
                      })

puts 'Raw text: '
puts resp.plaintext

async fn decrypt_key(client: &Client, key: &str, filename: &str) -> Result<(), Error> {
    // Open input text file and get contents as a string
    // input is a base-64 encoded string, so decode it:
    let data = fs::read_to_string(filename)
        .map(|input| {
            base64::decode(input).expect("Input file does not contain valid base 64 characters.")
        })
        .map(Blob::new);

    let resp = client
        .decrypt()
        .key_id(key)
        .ciphertext_blob(data.unwrap())
        .send()
        .await?;

    let inner = resp.plaintext.unwrap();
    let bytes = inner.as_ref();

    let s = String::from_utf8(bytes.to_vec()).expect("Could not convert to UTF-8");

    println!();
    println!("Decoded string:");
    println!("{}", s);

    Ok(())
}