Verwendung Encrypt mit einem AWS SDK oder CLI

Beispiel 1: Um den Inhalt einer Datei unter Linux oder macOS zu verschlüsseln

Der folgende encrypt Befehl demonstriert die empfohlene Methode zum Verschlüsseln von Daten mit der AWS CLI.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob | base64 \
    --decode > ExampleEncryptedFile

Der Befehl macht mehrere Dinge:

Verwendet den --plaintext Parameter, um die zu verschlüsselnden Daten anzugeben. Dieser Parameterwert muss Base64-kodiert sein. Der Wert des plaintext Parameters muss Base64-kodiert sein, oder Sie müssen das fileb:// Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen. Wenn sich die Datei nicht im aktuellen Verzeichnis befindet, geben Sie den vollständigen Dateipfad ein. Beispiel: fileb:///var/tmp/ExamplePlaintextFile oder fileb://C:\Temp\ExamplePlaintextFile. Weitere Informationen zum Lesen von AWS CLI-Parameterwerten aus einer Datei finden Sie unter Laden von Parametern aus einer Datei im Benutzerhandbuch für die AWS Befehlszeilenschnittstelle und Best Practices für lokale Dateiparameter im Blog des AWS Befehlszeilentools. Verwendet die --query Parameter --output und, um die Befehlsausgabe zu steuern.Diese Parameter extrahieren die verschlüsselten Daten, den so genannten Chiffretext, aus der Befehlsausgabe. Weitere Informationen zur Steuerung der Ausgabe finden Sie unter Steuerung des Befehls. Ausgabe im AWS Command Line Interface User Guide. Verwendet das base64 Hilfsprogramm, um die extrahierte Ausgabe in Binärdaten zu dekodieren. Der Chiffretext, der von einem erfolgreichen encrypt Befehl zurückgegeben wird, ist Base64-codierter Text. Sie müssen diesen Text dekodieren, bevor Sie ihn mit der AWS CLI entschlüsseln können. Speichert den binären Chiffretext in einer Datei. Der letzte Teil des Befehls (> ExampleEncryptedFile) speichert den binären Chiffretext in einer Datei, um die Entschlüsselung zu vereinfachen. Einen Beispielbefehl, der die AWS CLI zum Entschlüsseln von Daten verwendet, finden Sie in den Entschlüsselungsbeispielen.

Beispiel 2: Verwenden der AWS CLI zum Verschlüsseln von Daten unter Windows

Dieses Beispiel ist dasselbe wie das vorherige, außer dass es das certutil Tool anstelle von base64 verwendet. Für dieses Verfahren sind zwei Befehle erforderlich, wie im folgenden Beispiel gezeigt.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob > C:\Temp\ExampleEncryptedFile.base64

certutil -decode C:\Temp\ExampleEncryptedFile.base64 C:\Temp\ExampleEncryptedFile

Beispiel 3: Verschlüsselung mit einem asymmetrischen KMS-Schlüssel

Der folgende encrypt Befehl zeigt, wie Klartext mit einem asymmetrischen KMS-Schlüssel verschlüsselt wird. Der Parameter --encryption-algorithm muss angegeben werden. Wie bei allen encrypt CLI-Befehlen muss der plaintext Parameter base64-codiert sein, oder Sie müssen das fileb:// Präfix verwenden, das die AWS CLI anweist, Binärdaten aus der Datei zu lesen.

aws kms encrypt \
    --key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
    --encryption-algorithm RSAES_OAEP_SHA_256 \
    --plaintext fileb://ExamplePlaintextFile \
    --output text \
    --query CiphertextBlob | base64 \
    --decode > ExampleEncryptedFile

Mit diesem Befehl wird keine Ausgabe zurückgegeben.

    /**
     * Encrypts the given text asynchronously using the specified KMS client and key ID.
     *
     * @param keyId the ID of the KMS key to use for encryption
     * @param text the text to encrypt
     * @return a CompletableFuture that completes with the encrypted data as an SdkBytes object
     */
    public CompletableFuture<SdkBytes> encryptDataAsync(String keyId, String text) {
        SdkBytes myBytes = SdkBytes.fromUtf8String(text);
        EncryptRequest encryptRequest = EncryptRequest.builder()
            .keyId(keyId)
            .plaintext(myBytes)
            .build();

        CompletableFuture<EncryptResponse> responseFuture = getAsyncClient().encrypt(encryptRequest).toCompletableFuture();
        return responseFuture.whenComplete((response, ex) -> {
            if (response != null) {
                String algorithm = response.encryptionAlgorithm().toString();
                logger.info("The string was encrypted with algorithm {}.", algorithm);
            } else {
                throw new RuntimeException(ex);
            }
        }).thenApply(EncryptResponse::ciphertextBlob);
    }

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?,
) {
    val decryptRequest =
        DecryptRequest {
            ciphertextBlob = encryptedDataVal
            keyId = keyIdVal
        }
    KmsClient { region = "us-west-2" }.use { kmsClient ->
        val decryptResponse = kmsClient.decrypt(decryptRequest)
        val myVal = decryptResponse.plaintext

        // Print the decrypted data.
        print(myVal)
    }
}

    /***
     * @param string $keyId
     * @param string $text
     * @return Result
     */
    public function encrypt(string $keyId, string $text)
    {
        try {
            return $this->client->encrypt([
                'KeyId' => $keyId,
                'Plaintext' => $text,
            ]);
        }catch(KmsException $caught){
            if($caught->getAwsErrorMessage() == "DisabledException"){
                echo "The request was rejected because the specified KMS key is not enabled.\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 encrypt(self, key_id: str, text: str) -> str:
        """
        Encrypts text by using the specified key.

        :param key_id: The ARN or ID of the key to use for encryption.
        :param text: The text to encrypt.
        :return: The encrypted version of the text.
        """
        try:
            response = self.kms_client.encrypt(KeyId=key_id, Plaintext=text.encode())
            print(
                f"The string was encrypted with algorithm {response['EncryptionAlgorithm']}"
            )
            return response["CiphertextBlob"]
        except ClientError as err:
            if err.response["Error"]["Code"] == "DisabledException":
                logger.error(
                    "Could not encrypt because the key %s is disabled.", key_id
                )
            else:
                logger.error(
                    "Couldn't encrypt text. Here's why: %s",
                    err.response["Error"]["Message"],
                )
            raise

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

# ARN of the AWS KMS key.
#
# Replace the fictitious key ARN with a valid key ID

keyId = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'

text = '1234567890'

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

resp = client.encrypt({
                        key_id: keyId,
                        plaintext: text
                      })

# Display a readable version of the resulting encrypted blob.
puts 'Blob:'
puts resp.ciphertext_blob.unpack('H*')

async fn encrypt_string(
    verbose: bool,
    client: &Client,
    text: &str,
    key: &str,
    out_file: &str,
) -> Result<(), Error> {
    let blob = Blob::new(text.as_bytes());

    let resp = client.encrypt().key_id(key).plaintext(blob).send().await?;

    // Did we get an encrypted blob?
    let blob = resp.ciphertext_blob.expect("Could not get encrypted text");
    let bytes = blob.as_ref();

    let s = base64::encode(bytes);

    let mut ofile = File::create(out_file).expect("unable to create file");
    ofile.write_all(s.as_bytes()).expect("unable to write");

    if verbose {
        println!("Wrote the following to {:?}", out_file);
        println!("{}", s);
    }

    Ok(())
}