Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo `Encrypt` con un AWS SDK o una CLI
Gli esempi di codice seguenti mostrano come utilizzare `Encrypt`.
Gli esempi di operazioni sono estratti di codice da programmi più grandi e devono essere eseguiti nel contesto. È possibile visualizzare questa operazione nel contesto nel seguente esempio di codice:
+ [Informazioni di base](example_kms_Scenario_Basics_section.md)
------
#### [ CLI ]
**AWS CLI**
**Esempio 1: come crittografare il contenuto di un file in Linux o macOS.**
Il `encrypt` comando seguente illustra il metodo consigliato per crittografare i dati con la AWS CLI.
```
aws kms encrypt \
--key-id 1234abcd-12ab-34cd-56ef-1234567890ab \
--plaintext fileb://ExamplePlaintextFile \
--output text \
--query CiphertextBlob | base64 \
--decode > ExampleEncryptedFile
```
Il comando esegue diverse operazioni:
Utilizza il parametro `--plaintext` per indicare i dati da crittografare. Il valore di questo parametro deve essere codificato in base 64. Il valore del `plaintext` parametro deve essere codificato in base 64 oppure è necessario utilizzare il prefisso`fileb://`, che indica alla CLI di leggere i dati binari dal file. Se il AWS file non si trova nella directory corrente, digitare il percorso completo del file. Ad esempio: `fileb:///var/tmp/ExamplePlaintextFile` o `fileb://C:\Temp\ExamplePlaintextFile`. [Per ulteriori informazioni sulla lettura dei valori dei [parametri AWS CLI da un file, vedere Loading Parameters from a File](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file) nella *AWS Command Line Interface User Guide* e [Best Practices for Local File Parameters](https://blogs.aws.amazon.com/cli/post/TxLWWN1O25V1HE/Best-Practices-for-Local-File-Parameters) nel blog AWS Command Line Tool. Utilizza `--query` i parametri `--output` and per controllare l'output del comando. Questi parametri estraggono i dati crittografati, chiamati *ciphertext*, dall'output del comando.Per ulteriori informazioni sul controllo dell'output, vedere Controllo del comando Output](https://docs.aws.amazon.com/cli/latest/userguide/controlling-output.html) nella *Guida per l'utente dell'interfaccia a riga di AWS comando*. Utilizza l'`base64`utilità per decodificare l'output estratto in dati binari. Il testo cifrato restituito da un `encrypt` comando riuscito è testo con codifica in base64. È necessario decodificare questo testo prima di poter utilizzare la AWS CLI per decrittografarlo. Salva il testo cifrato binario in un file.La parte finale del comando `> ExampleEncryptedFile` () salva il testo cifrato binario in un file per semplificare la decrittografia. Per un comando di esempio che utilizza la AWS CLI per decrittografare i dati, consulta gli esempi di decrittografia.
**Esempio 2: utilizzo della AWS CLI per crittografare i dati su Windows**
Questo esempio è uguale a quello precedente, tranne per il fatto che utilizza lo strumento `certutil` al posto di `base64`. Questa procedura richiede due comandi, come illustrato nell’esempio seguente.
```
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
```
**Esempio 3: crittografia con una chiave KMS asimmetrica**
Il comando `encrypt` seguente mostra come crittografare il testo non crittografato con una chiave KMS asimmetrica. Il parametro `--encryption-algorithm` è obbligatorio. Come in tutti i comandi `encrypt` CLI, il `plaintext` parametro deve essere codificato in base 64 oppure è necessario utilizzare il prefisso`fileb://`, che indica alla CLI di leggere i dati binari dal file AWS .
```
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
```
Questo comando non produce alcun output.
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/kms/encrypt.html) in *AWS CLI Command Reference*.
------
#### [ Java ]
**SDK per Java 2.x**
C'è altro su. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/kms#code-examples).
```
/**
* 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 encryptDataAsync(String keyId, String text) {
SdkBytes myBytes = SdkBytes.fromUtf8String(text);
EncryptRequest encryptRequest = EncryptRequest.builder()
.keyId(keyId)
.plaintext(myBytes)
.build();
CompletableFuture 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);
}
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.aws.amazon.com/goto/SdkForJavaV2/kms-2014-11-01/Encrypt) nella *documentazione di riferimento dell’API AWS SDK for Java 2.x *.
------
#### [ Kotlin ]
**SDK per Kotlin**
C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/kms#code-examples).
```
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.fromEnvironment { 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)
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://sdk.amazonaws.com/kotlin/api/latest/index.html) nella *documentazione di riferimento dell’API AWS SDK per Kotlin*.
------
#### [ PHP ]
**SDK per PHP**
C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/example_code/kms#code-examples).
```
/***
* @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;
}
}
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.aws.amazon.com/goto/SdkForPHPV3/kms-2014-11-01/Encrypt) nella *documentazione di riferimento dell’API AWS SDK per PHP *.
------
#### [ Python ]
**SDK per Python (Boto3)**
C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/kms#code-examples).
```
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) -> bytes:
"""
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
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.aws.amazon.com/goto/boto3/kms-2014-11-01/Encrypt) nella *documentazione di riferimento dell’API AWS SDK per Python (Boto3)*.
------
#### [ Ruby ]
**SDK per Ruby**
C'è dell'altro GitHub. Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/ruby/example_code/kms#code-examples).
```
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*')
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.aws.amazon.com/goto/SdkForRubyV3/kms-2014-11-01/Encrypt) nella *documentazione di riferimento dell’API AWS SDK per Ruby *.
------
#### [ Rust ]
**SDK per Rust**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/examples/kms#code-examples).
```
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(())
}
```
+ Per informazioni dettagliate sull’API, consulta [Encrypt](https://docs.rs/aws-sdk-kms/latest/aws_sdk_kms/client/struct.Client.html#method.encrypt) nella *documentazione di riferimento dell’API SDK AWS per Rust*.
------
#### [ SAP ABAP ]
**SDK per SAP ABAP**
C'è altro da fare. GitHub Trova l'esempio completo e scopri di più sulla configurazione e l'esecuzione nel [Repository di esempi di codice AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/kms#code-examples).
```
TRY.
" iv_key_id = 'arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab'
" iv_plaintext contains the data to encrypt
oo_result = lo_kms->encrypt(
iv_keyid = iv_key_id
iv_plaintext = iv_plaintext
).
MESSAGE 'Text encrypted successfully.' TYPE 'I'.
CATCH /aws1/cx_kmsdisabledexception.
MESSAGE 'The key is disabled.' TYPE 'E'.
CATCH /aws1/cx_kmsnotfoundexception.
MESSAGE 'Key not found.' TYPE 'E'.
CATCH /aws1/cx_kmskmsinternalex.
MESSAGE 'An internal error occurred.' TYPE 'E'.
ENDTRY.
```
+ Per i dettagli sull'API, [consulta Encrypt](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP* API reference.
------
Per un elenco completo delle guide per sviluppatori AWS SDK e degli esempi di codice, consulta. [Utilizzo di questo servizio con un AWS SDK](sdk-general-information-section.md) Questo argomento include anche informazioni su come iniziare e dettagli sulle versioni precedenti dell’SDK.