Gunakan Decrypt dengan AWS SDK atau CLI

Contoh 1: Untuk mendekripsi pesan terenkripsi dengan kunci simetris KMS (Linux dan macOS)

Contoh decrypt perintah berikut menunjukkan cara yang disarankan untuk mendekripsi data dengan. AWS CLI Versi ini menunjukkan cara mendekripsi data di bawah kunci simetrisKMS.

Berikan ciphertext dalam file.Dalam nilai --ciphertext-blob parameter, gunakan fileb:// awalan, yang memberitahu CLI untuk membaca data dari file biner. Jika file tidak ada di direktori saat ini, ketik path lengkap ke file. Untuk informasi selengkapnya tentang membaca nilai AWS CLI parameter dari file, lihat Memuat AWS CLI parameter dari file < https://docs.aws.amazon.com/cli/ latest/userguide/cli - usage-parameters-file .html> di Panduan Pengguna Antarmuka Baris AWS Perintah dan Praktik Terbaik untuk Parameter File Lokal< https://aws.amazon.com/blogs/ pengembang/ best-practices-for-local -file-parameters/> di Blog Alat Baris AWS Perintah. Tentukan kunci untuk mendekripsi cipherText. Parameter tidak diperlukan saat mendekripsi dengan KMS kunci simetris. --key-id KMS AWS KMSbisa mendapatkan ID kunci dari KMS kunci yang digunakan untuk mengenkripsi data dari metadata dalam ciphertext. Tetapi selalu merupakan praktik terbaik untuk menentukan KMS kunci yang Anda gunakan. Praktek ini memastikan bahwa Anda menggunakan KMS kunci yang Anda inginkan, dan mencegah Anda dari secara tidak sengaja mendekripsi ciphertext menggunakan KMS kunci yang tidak Anda percayai. Minta output plaintext sebagai nilai --query teks.Parameter memberitahu untuk mendapatkan hanya nilai bidang dari output. CLI Plaintext --outputParameter mengembalikan output sebagai text.base64-decode plaintext dan menyimpannya dalam file.Contoh berikut pipa (|) nilai Plaintext parameter ke utilitas Base64, yang menerjemahkan itu. Kemudian, itu mengalihkan (>) output yang diterjemahkan ke file. ExamplePlaintext

Sebelum menjalankan perintah ini, ganti ID kunci contoh dengan ID kunci yang valid dari AWS akun Anda.

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

Perintah ini tidak menghasilkan output. Output dari decrypt perintah adalah base64-decoded dan disimpan dalam file.

Untuk informasi selengkapnya, lihat Mendekripsi di Referensi Layanan API Manajemen AWS Utama.

Contoh 2: Untuk mendekripsi pesan terenkripsi dengan KMS kunci simetris (prompt perintah Windows)

Contoh berikut adalah sama dengan yang sebelumnya kecuali bahwa ia menggunakan certutil utilitas untuk Base64-decode data plaintext. Prosedur ini membutuhkan dua perintah, seperti yang ditunjukkan pada contoh berikut.

Sebelum menjalankan perintah ini, ganti ID kunci contoh dengan ID kunci yang valid dari AWS akun Anda.

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

Jalankan perintah certutil.

certutil -decode ExamplePlaintextFile.base64 ExamplePlaintextFile

Output:

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

Untuk informasi selengkapnya, lihat Mendekripsi di Referensi Layanan API Manajemen AWS Utama.

Contoh 3: Untuk mendekripsi pesan terenkripsi dengan kunci asimetris KMS (Linux dan macOS)

Contoh decrypt perintah berikut menunjukkan cara mendekripsi data yang dienkripsi di bawah kunci asimetris. RSA KMS

Saat menggunakan KMS kunci asimetris, encryption-algorithm parameter, yang menentukan algoritma yang digunakan untuk mengenkripsi plaintext, diperlukan.

Sebelum menjalankan perintah ini, ganti ID kunci contoh dengan ID kunci yang valid dari AWS akun Anda.

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

Perintah ini tidak menghasilkan output. Output dari decrypt perintah adalah base64-decoded dan disimpan dalam file.

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

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