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à.
# SDK di crittografia AWS per C
SDK di crittografia AWS per C Fornisce una libreria di crittografia lato client per gli sviluppatori che scrivono applicazioni in C. Serve anche come base per le implementazioni di linguaggi di programmazione di livello superiore. AWS Encryption SDK
Come tutte le implementazioni di, offre funzionalità avanzate di protezione dei AWS Encryption SDK SDK di crittografia AWS per C dati. Queste includono la [crittografia envelope](concepts.md#envelope-encryption), dati autenticati aggiuntivi (AAD) e [suite di algoritmi](concepts.md#crypto-algorithm) di chiavi simmetriche, autenticate e sicure, come, ad esempio, AES-GCM a 256 bit con derivazione della chiave e firma.
Tutte le implementazioni specifiche del linguaggio sono completamente interoperabili. AWS Encryption SDK [Ad esempio, puoi crittografare i dati con SDK di crittografia AWS per C e decrittografarli con [qualsiasi implementazione linguistica supportata](programming-languages.md), inclusa l'Encryption AWS CLI.](crypto-cli.md)
SDK di crittografia AWS per C Richiede l' AWS SDK per C\$1\$1 interazione con (). AWS Key Management Service AWS KMSÈ necessario utilizzarlo solo se si utilizza il [AWS KMS portachiavi](use-kms-keyring.md) opzionale. Tuttavia, AWS Encryption SDK non richiede AWS KMS alcun altro AWS servizio.
**Ulteriori informazioni**
+ Per i dettagli sulla programmazione con SDK di crittografia AWS per C, consulta gli [esempi in C](c-examples.md), gli [esempi](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) nel [aws-encryption-sdk-c repository](https://github.com/aws/aws-encryption-sdk-c/) on GitHub e la [documentazione dell'SDK di crittografia AWS per C API](https://aws.github.io/aws-encryption-sdk-c/html/).
+ Per una discussione su come utilizzare il per SDK di crittografia AWS per C crittografare i dati in modo da poterli decrittografare in più parti Regioni AWS, vedi [Come decrittografare testi cifrati in più aree con C nel Security](https://aws.amazon.com/blogs/security/how-to-decrypt-ciphertexts-multiple-regions-aws-encryption-sdk-in-c/) Blog. AWS Encryption SDK AWS
**Topics**
+ [Installazione](c-language-installation.md)
+ [Utilizzo dell'SDK per C](c-language-using.md)
+ [Esempi](c-examples.md)
# Installazione del SDK di crittografia AWS per C
Installazione della versione più recente della SDK di crittografia AWS per C.
**Nota**
[Tutte le versioni SDK di crittografia AWS per C precedenti alla 2.0.0 sono in fase di sviluppo. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)
È possibile eseguire l'aggiornamento in tutta sicurezza dalla versione 2.0. *x* e versioni successive alla versione più recente di SDK di crittografia AWS per C senza modifiche al codice o ai dati. Tuttavia, nella versione 2.0 sono state introdotte [nuove funzionalità di sicurezza](about-versions.md#version-2). *x* non sono retrocompatibili. Per eseguire l'aggiornamento da versioni precedenti alla 1.7. *x* alla versione 2.0. *x* e versioni successive, è necessario prima eseguire l'aggiornamento alla versione più recente 1. versione *x* di SDK di crittografia AWS per C. Per informazioni dettagliate, vedi [Migrazione del tuo AWS Encryption SDK](migration.md).
Puoi trovare istruzioni dettagliate per l'installazione e la compilazione SDK di crittografia AWS per C nel [file README](https://github.com/aws/aws-encryption-sdk-c/#readme) del [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)repository. Include istruzioni per la creazione su piattaforme Amazon Linux, Ubuntu, macOS e Windows.
Prima di iniziare, decidi se desideri utilizzare i [AWS KMS portachiavi](use-kms-keyring.md) in. AWS Encryption SDK Se si utilizza un AWS KMS portachiavi, è necessario installare il. AWS SDK per C\$1\$1 L' AWS SDK è necessario per interagire con [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)()AWS KMS. Quando utilizzi i AWS KMS portachiavi, AWS Encryption SDK vengono utilizzati AWS KMS per generare e proteggere le chiavi di crittografia che proteggono i tuoi dati.
Non è necessario installarlo AWS SDK per C\$1\$1 se si utilizza un altro tipo di portachiavi, ad esempio un portachiavi AES non elaborato, un portachiavi RSA non elaborato o un portachiavi multiplo che non include un portachiavi. AWS KMS Tuttavia, quando si utilizza un tipo di portachiavi non elaborato, è necessario generare e proteggere le proprie chiavi di avvolgimento non elaborate.
Se riscontri problemi con l'installazione, segnala [un problema](https://github.com/aws/aws-encryption-sdk-c/issues) nel `aws-encryption-sdk-c` repository o utilizza uno dei link di feedback in questa pagina.
# Usando il SDK di crittografia AWS per C
Questo argomento spiega alcune delle funzionalità di SDK di crittografia AWS per C che non sono supportate in altre implementazioni del linguaggio di programmazione.
Gli esempi in questa sezione mostrano come utilizzare la [versione 2.0. ](about-versions.md)*x* e versioni successive di SDK di crittografia AWS per C. Per esempi che utilizzano versioni precedenti, trova la tua versione nell'elenco [Releases](https://github.com/aws/aws-encryption-sdk-c/releases) del [aws-encryption-sdk-c repository del repository](https://github.com/aws/aws-encryption-sdk-c/) su. GitHub
[Per i dettagli sulla programmazione con SDK di crittografia AWS per C, consulta gli [esempi in C](c-examples.md), gli [esempi](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) nel [aws-encryption-sdk-c repository](https://github.com/aws/aws-encryption-sdk-c/) on GitHub e la documentazione dell'SDK di crittografia AWS per C API.](https://aws.github.io/aws-encryption-sdk-c/html/)
Consulta anche: [Portachiavi](choose-keyring.md)
**Topics**
+ [Modelli per la crittografia e la decrittazione dei dati](#c-language-using-pattern)
+ [Conteggio dei riferimenti](#c-language-using-release)
## Modelli per la crittografia e la decrittazione dei dati
Quando si utilizza il SDK di crittografia AWS per C, si segue uno schema simile al seguente: si crea un [portachiavi](concepts.md#keyring), si crea una [CMM](concepts.md#crypt-materials-manager) che utilizza il portachiavi, si crea una sessione che utilizza il CMM (e il portachiavi) e quindi si elabora la sessione.
1. Stringhe di errore di caricamento.
Chiama il `aws_cryptosdk_load_error_strings()` metodo nel tuo codice C o C\$1\$1. Carica informazioni sugli errori che sono molto utili per il debug.
Devi chiamarlo solo una volta, ad esempio nel tuo metodo. `main`
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
2. Crea un keyring.
Configura il [keyring](concepts.md#keyring) con le chiavi di wrapping da utilizzare per crittografare le chiavi di dati. In questo esempio viene utilizzato un [AWS KMS portachiavi](use-kms-keyring.md) con uno AWS KMS key, ma è possibile utilizzare qualsiasi tipo di portachiavi al suo posto.
Per identificare un elemento AWS KMS key in un portachiavi di crittografia in SDK di crittografia AWS per C, specificare una [chiave ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) o un [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ARN. In un keyring di decrittografia devi utilizzare un ARN di chiave. Per informazioni dettagliate, vedi [Identificazione AWS KMS keys in un portachiavi AWS KMS](use-kms-keyring.md#kms-keyring-id).
```
const char * KEY_ARN = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(KEY_ARN);
```
3. Crea una sessione.
In SDK di crittografia AWS per C, si utilizza una *sessione* per crittografare un singolo messaggio di testo in chiaro o decrittografare un singolo messaggio di testo cifrato, indipendentemente dalla sua dimensione. La sessione mantiene lo stato del messaggio durante tutta l'elaborazione.
Configura la sessione con un allocatore, un CMM e una modalità: `AWS_CRYPTOSDK_ENCRYPT` o `AWS_CRYPTOSDK_DECRYPT`. Per modificare la modalità della sessione, utilizza il metodo `aws_cryptosdk_session_reset`.
Quando crei una sessione con un portachiavi, crea SDK di crittografia AWS per C automaticamente un gestore di materiali crittografici (CMM) predefinito per te. Non è necessario creare, mantenere o eliminare in modo permanente questo oggetto.
Ad esempio, la sessione seguente utilizza l'allocatore e il keyring definito nella fase 1. Quando esegui la crittografia dei dati, la modalità è `AWS_CRYPTOSDK_ENCRYPT`.
```
struct aws_cryptosdk_session * session = aws_cryptosdk_session_new_from_keyring_2(allocator, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
```
4. Esegui la crittografia o la decrittazione dei dati.
Per elaborare i dati della sessione, utilizza il metodo `aws_cryptosdk_session_process`. Se il buffer di input è abbastanza grande da contenere l'intero testo in chiaro e il buffer di output è abbastanza grande da contenere l'intero testo cifrato, puoi chiamare. `aws_cryptosdk_session_process_full` Tuttavia, se è necessario gestire lo streaming di dati, è possibile effettuare chiamate in loop. `aws_cryptosdk_session_process` Per un esempio, consulta [file\$1streaming.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/file_streaming.cpp). `aws_cryptosdk_session_process_full`È stato introdotto nelle AWS Encryption SDK versioni 1.9. *x* e 2.2. *x*.
Quando la sessione è configurata per crittografare i dati, i campi di testo normale descrivono l'input, mentre quelli di testo cifrato l'output. Il campo `plaintext` contiene il messaggio da crittografare, mentre il campo `ciphertext` riceve il [messaggio crittografato](message-format.md) restituito dal metodo di crittografia.
```
/* Encrypting data */
aws_cryptosdk_session_process_full(session,
ciphertext,
ciphertext_buffer_size,
&ciphertext_length,
plaintext,
plaintext_length)
```
Quando la sessione è configurata per decrittare i dati, i campi di testo cifrato descrivono l'input, mentre quelli di testo normale l'output. Il campo `ciphertext` contiene il [messaggio crittografato](message-format.md) restituito dal metodo di crittografia, mentre il campo `plaintext` riceve il messaggio di testo normale restituito dal metodo di decrittazione.
Per decrittare i dati, chiama il metodo `aws_cryptosdk_session_process_full`.
```
/* Decrypting data */
aws_cryptosdk_session_process_full(session,
plaintext,
plaintext_buffer_size,
&plaintext_length,
ciphertext,
ciphertext_length)
```
## Conteggio dei riferimenti
Per evitare perdite di memoria, assicurati di rilasciare i riferimenti a tutti gli oggetti che crei quando finisci di utilizzarli. In caso contrario, potrebbero verificarsi perdite di memoria. L'SDK offre dei metodi per semplificare questa operazione.
Ogni volta che crei un oggetto padre con uno dei seguenti oggetti figlio, l'oggetto padre ottiene e mantiene un riferimento all'oggetto figlio, come indicato di seguito:
+ Un [keyring](concepts.md#keyring), ad esempio la creazione di una sessione con un keyring
+ Un [gestore di materiali crittografici](concepts.md#crypt-materials-manager) (CMM) predefinito, ad esempio la creazione di una sessione o una CMM personalizzata con una CMM predefinita
+ Una [cache della chiave di dati](data-key-caching.md), ad esempio un CMM di caching con un keyring e una cache
A meno che non sia necessario un riferimento indipendente all'oggetto figlio, puoi rilasciare il riferimento all'oggetto figlio non appena crei l'oggetto padre. Il rimanente riferimento all'oggetto figlio viene rilasciato quando l'oggetto padre viene eliminato in modo permanente. Questo modello consente di mantenere il riferimento a ogni oggetto solo per il tempo necessario ed evita le perdite di memoria causate da riferimenti non rilasciati.
Sarai responsabile solo del rilascio dei riferimenti agli oggetti figlio creati in modo esplicito. Non sei responsabile della gestione dei riferimenti a qualsiasi oggetto creato dall'SDK. Se l'SDK crea un oggetto, ad esempio la CMM predefinita che il `aws_cryptosdk_caching_cmm_new_from_keyring` metodo aggiunge a una sessione, l'SDK gestisce la creazione e la distruzione dell'oggetto e dei relativi riferimenti.
Nell'esempio seguente, quando crei una sessione con un [keyring](concepts.md#keyring), la sessione ottiene un riferimento al keyring e mantiene tale riferimento fino a quando la sessione non viene eliminata in modo permanente. Se non è necessario mantenere un riferimento aggiuntivo al keyring, puoi utilizzare il metodo `aws_cryptosdk_keyring_release` per rilasciare l'oggetto keyring non appena viene creata la sessione. Questo metodo riduce il conteggio dei riferimenti per il keyring. Il riferimento della sessione al keyring viene rilasciato quando chiami `aws_cryptosdk_session_destroy` per eliminare in modo permanente la sessione.
```
// The session gets a reference to the keyring.
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, keyring);
// After you create a session with a keyring, release the reference to the keyring object.
aws_cryptosdk_keyring_release(keyring);
```
Per attività più complesse, come riutilizzare un portachiavi per più sessioni o specificare una suite di algoritmi in una CMM, potrebbe essere necessario mantenere un riferimento indipendente all'oggetto. In tal caso, non chiamare immediatamente i metodi di rilascio. Al contrario, rilascia i riferimenti quando non utilizzi più gli oggetti, oltre ad eliminare in modo permanente la sessione.
[Questa tecnica di conteggio dei riferimenti funziona anche quando si utilizzano alternative CMMs, come la cache CMM per la memorizzazione nella cache delle chiavi di dati.](data-key-caching.md) Quando si crea una CMM memorizzata nella cache da una cache e da un portachiavi, la CMM memorizzata nella cache ottiene un riferimento a entrambi gli oggetti. A meno che non ne abbiate bisogno per un'altra attività, potete rilasciare i riferimenti indipendenti alla cache e al portachiavi non appena viene creata la CMM che memorizza nella cache. Quindi, quando create una sessione con la CMM che memorizza nella cache, potete rilasciare il riferimento alla CMM che memorizza nella cache.
Sei responsabile solo del rilascio dei riferimenti agli oggetti creati in modo esplicito. Gli oggetti creati automaticamente dai metodi, come la CMM predefinita che sta alla base della CMM memorizzata nella cache, vengono gestiti dal metodo.
```
/ Create the caching CMM from a cache and a keyring.
struct aws_cryptosdk_cmm *caching_cmm = aws_cryptosdk_caching_cmm_new_from_keyring(allocator, cache, kms_keyring, NULL, 60, AWS_TIMESTAMP_SECS);
// Release your references to the cache and the keyring.
aws_cryptosdk_materials_cache_release(cache);
aws_cryptosdk_keyring_release(kms_keyring);
// Create a session with the caching CMM.
struct aws_cryptosdk_session *session = aws_cryptosdk_session_new_from_cmm_2(allocator, AWS_CRYPTOSDK_ENCRYPT, caching_cmm);
// Release your references to the caching CMM.
aws_cryptosdk_cmm_release(caching_cmm);
// ...
aws_cryptosdk_session_destroy(session);
```
# SDK di crittografia AWS per C esempi
Gli esempi seguenti mostrano come utilizzare per crittografare SDK di crittografia AWS per C e decrittografare i dati.
Gli esempi in questa sezione mostrano come utilizzare le versioni 2.0. *x* e successive di SDK di crittografia AWS per C. Per esempi che utilizzano versioni precedenti, trova la tua versione nell'elenco delle [versioni](https://github.com/aws/aws-encryption-sdk-c/releases) del [aws-encryption-sdk-c repository del repository](https://github.com/aws/aws-encryption-sdk-c/) su. GitHub
Quando installi e compili SDK di crittografia AWS per C, il codice sorgente di questi e altri esempi viene incluso nella `examples` sottodirectory, e vengono compilati e incorporati nella directory. `build` Puoi trovarli anche nella sottodirectory [examples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) del [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)repository su. GitHub
**Topics**
+ [Crittografia e decrittazione di stringhe](#c-example-strings)
## Crittografia e decrittazione di stringhe
L'esempio seguente mostra come utilizzare per crittografare e SDK di crittografia AWS per C decrittografare una stringa.
Questo esempio presenta il [AWS KMS portachiavi](use-kms-keyring.md), un tipo di portachiavi che utilizza un AWS KMS key in [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/) per generare e crittografare le chiavi di dati. L'esempio include codice scritto in C\$1\$1. SDK di crittografia AWS per C Richiede la AWS SDK per C\$1\$1 chiamata AWS KMS quando si usano i AWS KMS portachiavi. Se utilizzi un portachiavi che non interagisce con AWS KMS, ad esempio un portachiavi AES non elaborato, un portachiavi RSA non elaborato o un portachiavi multiplo che non include un AWS KMS portachiavi, non è necessario. AWS SDK per C\$1\$1
[https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) Per informazioni su come identificarle AWS KMS keys in un AWS KMS portachiavi, consulta[Identificazione AWS KMS keys in un portachiavi AWS KMS](use-kms-keyring.md#kms-keyring-id).
**Vedi l'esempio di codice completo**: [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp)
**Topics**
+ [Crittografare una stringa](#c-example-string-encrypt)
+ [Decrittare una stringa](#c-example-string-decrypt)
### Crittografare una stringa
La prima parte di questo esempio utilizza un AWS KMS portachiavi con uno AWS KMS key per crittografare una stringa di testo in chiaro.
Passaggio 1. Stringhe di errore di caricamento.
Chiama il `aws_cryptosdk_load_error_strings()` metodo nel codice C o C\$1\$1. Carica informazioni sugli errori che sono molto utili per il debug.
Devi chiamarlo solo una volta, ad esempio nel tuo metodo. `main`
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Fase 2: Costruisci il portachiavi.
Crea un AWS KMS portachiavi per la crittografia. Il portachiavi in questo esempio è configurato con uno AWS KMS key, ma è possibile configurare un AWS KMS portachiavi con più portachiavi AWS KMS keys, anche AWS KMS keys in account diversi Regioni AWS e diversi.
Per identificare un elemento AWS KMS key in un portachiavi di crittografia in SDK di crittografia AWS per C, specificare una [chiave ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) o un [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ARN. In un keyring di decrittografia devi utilizzare un ARN di chiave. Per informazioni dettagliate, vedi [Identificazione AWS KMS keys in un portachiavi AWS KMS](use-kms-keyring.md#kms-keyring-id).
[Identificazione AWS KMS keys in un portachiavi AWS KMS](use-kms-keyring.md#kms-keyring-id)
Quando si crea un portachiavi con più chiavi AWS KMS keys, si specifica la chiave di dati in testo normale AWS KMS key utilizzata per generare e crittografare la stessa chiave di dati in testo semplice e una matrice opzionale aggiuntiva AWS KMS keys che crittografa la stessa chiave di dati in testo semplice. In questo caso, si specifica solo il generatore. AWS KMS key
Prima di eseguire questo codice, sostituisci l'ARN della chiave di esempio con uno valido.
```
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
```
Fase 3: creare una sessione.
Crea una sessione utilizzando l'allocatore, un enumeratore di modalità e il keyring.
Ogni sessione richiede una modalità: `AWS_CRYPTOSDK_ENCRYPT` per la crittografia e `AWS_CRYPTOSDK_DECRYPT` per la decrittazione. Per modificare la modalità di una sessione esistente, utilizza il metodo `aws_cryptosdk_session_reset`.
Dopo aver creato una sessione con il keyring, puoi rilasciare il riferimento al keyring con il metodo fornito dall'SDK. La sessione mantiene un riferimento all'oggetto keyring durante la sua durata. I riferimenti al keyring e agli oggetti sessione vengono rilasciati quando si distrugge la sessione. Questa tecnica di [conteggio dei riferimenti](c-language-using.md#c-language-using-release) aiuta a prevenire perdite di memoria e a impedire che gli oggetti vengano rilasciati mentre sono in uso.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Fase 4: impostare il contesto di crittografia.
Un [contesto di crittografia](concepts.md#encryption-context) è rappresentato da tipi di dati autenticati aggiuntivi arbitrari e non segreti. Quando si fornisce un contesto di crittografia su encrypt, associa AWS Encryption SDK crittograficamente il contesto di crittografia al testo cifrato in modo che sia necessario lo stesso contesto di crittografia per decrittografare i dati. L'utilizzo di un contesto di crittografia è facoltativo, ma viene consigliato come best practice.
Crea innanzitutto una tabella hash che includa le stringhe del contesto di crittografia.
```
/* Allocate a hash table for the encryption context */
int set_up_enc_ctx(struct aws_allocator *alloc, struct aws_hash_table *my_enc_ctx)
// Create encryption context strings
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key1, "Example");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value1, "String");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_key2, "Company");
AWS_STATIC_STRING_FROM_LITERAL(enc_ctx_value2, "MyCryptoCorp");
// Put the key-value pairs in the hash table
aws_hash_table_put(my_enc_ctx, enc_ctx_key1, (void *)enc_ctx_value1, &was_created)
aws_hash_table_put(my_enc_ctx, enc_ctx_key2, (void *)enc_ctx_value2, &was_created)
```
Ottieni un puntatore modificabile per il contesto di crittografia nella sessione. Quindi, utilizza la funzione `aws_cryptosdk_enc_ctx_clone` per copiare il contesto di crittografia nella sessione. Una copia viene salvata in `my_enc_ctx` per la convalida del valore dopo la decrittazione dei dati.
Il contesto di crittografia fa parte della sessione, non è un parametro assegnato alla funzione di elaborazione della sessione. Questo garantisce che lo stesso contesto di crittografia venga utilizzato per ogni segmento di un messaggio, anche se la funzione di elaborazione della sessione viene chiamata più volte per crittografare l'intero messaggio.
```
struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr_mut(session);
aws_cryptosdk_enc_ctx_clone(alloc, session_enc_ctx, my_enc_ctx)
```
Fase 5: crittografare la stringa.
Per crittografare la stringa di testo normale, utilizza il metodo `aws_cryptosdk_session_process_full` con la sessione in modalità di crittografia. Questo metodo, introdotto nelle versioni 1.9. AWS Encryption SDK *x* e 2.2. *x*, è progettato per la crittografia e la decrittografia non in streaming. Per gestire i dati in streaming, chiamali `aws_cryptosdk_session_process` in un loop.
Durante la crittografia, i campi in testo normale sono destinati all'input, mentre quelli cifrati sono i campi di output. Al termine dell'elaborazione, il campo `ciphertext_output` contiene il [messaggio crittografato](concepts.md#message), inclusi il testo cifrato effettivo, le chiavi di dati crittografate e il contesto di crittografia. È possibile decrittografare questo messaggio crittografato utilizzando il AWS Encryption SDK per qualsiasi linguaggio di programmazione supportato.
```
/* Gets the length of the plaintext that the session processed */
size_t ciphertext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
ciphertext_output,
ciphertext_buf_sz_output,
&ciphertext_len_output,
plaintext_input,
plaintext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 8;
}
```
Passaggio 6: pulire la sessione.
Il passaggio finale distrugge la sessione, inclusi i riferimenti alla CMM e al portachiavi.
Se preferisci, invece di distruggere la sessione, puoi riutilizzare la sessione con lo stesso portachiavi e la stessa CMM per decrittografare la stringa o per crittografare o decrittografare altri messaggi. Per utilizzare la sessione per la decrittazione, scegli il metodo `aws_cryptosdk_session_reset` per modificare la modalità in `AWS_CRYPTOSDK_DECRYPT`.
### Decrittare una stringa
La seconda parte di questo esempio spiega come decrittare un messaggio crittografato che contiene il testo cifrato della stringa originale.
Passaggio 1: caricare le stringhe di errore.
Chiama il `aws_cryptosdk_load_error_strings()` metodo nel tuo codice C o C\$1\$1. Carica informazioni sugli errori che sono molto utili per il debug.
Devi chiamarlo solo una volta, ad esempio nel tuo metodo. `main`
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Fase 2: Costruisci il portachiavi.
Quando decifri i dati AWS KMS, trasmetti il [messaggio crittografato](concepts.md#message) restituito dall'API di crittografia. L'[API Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) non accetta un input as. AWS KMS key AWS KMS Utilizza invece lo stesso AWS KMS key per decrittografare il testo cifrato che ha usato per crittografarlo. Tuttavia, AWS Encryption SDK consente di specificare un AWS KMS portachiavi con crittografia e decrittografia. AWS KMS keys
In fase di decrittografia, è possibile configurare un portachiavi solo con AWS KMS keys quello che si desidera utilizzare per decrittografare il messaggio crittografato. Ad esempio, potresti voler creare un portachiavi con solo AWS KMS key quello utilizzato da un particolare ruolo all'interno dell'organizzazione. Non ne AWS Encryption SDK useranno mai uno AWS KMS key a meno che non compaia nel portachiavi di decrittografia. Se l'SDK non è AWS KMS keys in grado di decrittografare le chiavi di dati crittografate utilizzando il portachiavi fornito, o perché nessuna delle chiavi presenti AWS KMS keys nel portachiavi è stata utilizzata per crittografare nessuna delle chiavi dati o perché il chiamante non è autorizzato a utilizzare il portachiavi incluso AWS KMS keys nel portachiavi per decrittografare, la chiamata di decrittografia ha esito negativo.
[Quando si specifica un portachiavi AWS KMS key per la decrittografia, è necessario utilizzare la relativa chiave ARN.](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) [Gli alias ARNs](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) sono consentiti solo nei portachiavi di crittografia. Per informazioni su come identificarli AWS KMS keys in un AWS KMS portachiavi, consulta. [Identificazione AWS KMS keys in un portachiavi AWS KMS](use-kms-keyring.md#kms-keyring-id)
In questo esempio, specifichiamo un portachiavi configurato con lo stesso AWS KMS key utilizzato per crittografare la stringa. Prima di eseguire questo codice, sostituisci l'ARN della chiave di esempio con uno valido.
```
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
struct aws_cryptosdk_keyring *kms_keyring =
Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
```
Fase 3: creare una sessione.
Crea una sessione utilizzando l'allocatore e il keyring. Per configurare la sessione per la decrittazione, configura la sessione con la modalità `AWS_CRYPTOSDK_DECRYPT`.
Dopo aver creato una sessione con un keyring, puoi rilasciare il riferimento al keyring con il metodo fornito dall'SDK. La sessione mantiene un riferimento all'oggetto keyring durante la sua durata e sia la sessione che il keyring vengono rilasciati quando si distrugge la sessione. Questa tecnica di conteggio dei riferimenti aiuta a prevenire perdite di memoria e a impedire che gli oggetti vengano rilasciati mentre sono in uso.
```
struct aws_cryptosdk_session *session =
aws_cryptosdk_session_new_from_keyring_2(alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
/* When you add the keyring to the session, release the keyring object */
aws_cryptosdk_keyring_release(kms_keyring);
```
Fase 4: decrittare la stringa.
Per decrittare la stringa, utilizza il metodo `aws_cryptosdk_session_process_full` con la sessione configurata per la decrittazione. Questo metodo, introdotto nelle AWS Encryption SDK versioni 1.9. *x* e 2.2. *x*, è progettato per la crittografia e la decrittografia non in streaming. Per gestire i dati in streaming, chiamali `aws_cryptosdk_session_process` in un loop.
Durante la decrittazione, i campi in testo cifrato sono destinati all'input, mentre quelli in testo normale sono i campi di output. Il campo `ciphertext_input` contiene il [messaggio crittografato](message-format.md) restituito dal metodo di crittografia. Al termine dell'elaborazione, il campo `plaintext_output` contiene la stringa di testo normale (decrittato).
```
size_t plaintext_len_output;
if (AWS_OP_SUCCESS != aws_cryptosdk_session_process_full(session,
plaintext_output,
plaintext_buf_sz_output,
&plaintext_len_output,
ciphertext_input,
ciphertext_len_input)) {
aws_cryptosdk_session_destroy(session);
return 13;
}
```
Fase 5: verificare il contesto di crittografia.
Assicurati che il contesto di crittografia effettivo, quello utilizzato per decrittografare il messaggio, contenga il contesto di crittografia fornito durante la crittografia del messaggio. Il contesto di crittografia effettivo potrebbe includere coppie supplementari, perché il [responsabile dei materiali crittografici](concepts.md#crypt-materials-manager) (CMM) può aggiungere delle coppie a tale contesto prima della crittografia del messaggio.
In SDK di crittografia AWS per C, non è necessario fornire un contesto di crittografia durante la decrittografia, poiché il contesto di crittografia è incluso nel messaggio crittografato restituito dall'SDK. Tuttavia, prima di restituire il messaggio di testo normale, la funzione di decrittazione deve verificare che tutte le coppie nel contesto di crittografia fornito siano anche presenti nel contesto di crittografia utilizzato per decrittare il messaggio.
Ottieni innanzitutto un puntatore di sola lettura per la tabella hash nella sessione. Questa tabella hash contiene il contesto di crittografia utilizzato per decrittare il messaggio.
```
const struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr(session);
```
Quindi, esamina il contesto di crittografia nella tabella hash `my_enc_ctx` copiata durante la crittografia. Verifica che ogni coppia nella tabella hash `my_enc_ctx` utilizzata per la crittografia sia presente nella tabella hash `session_enc_ctx` utilizzata per la decrittazione. Se una chiave è mancante o ha un valore differente, interrompi l'elaborazione e scrivi un messaggio di errore.
```
for (struct aws_hash_iter iter = aws_hash_iter_begin(my_enc_ctx); !aws_hash_iter_done(&iter);
aws_hash_iter_next(&iter)) {
struct aws_hash_element *session_enc_ctx_kv_pair;
aws_hash_table_find(session_enc_ctx, iter.element.key, &session_enc_ctx_kv_pair)
if (!session_enc_ctx_kv_pair ||
!aws_string_eq(
(struct aws_string *)iter.element.value, (struct aws_string *)session_enc_ctx_kv_pair->value)) {
fprintf(stderr, "Wrong encryption context!\n");
abort();
}
}
```
Passaggio 6: pulire la sessione.
Dopo aver verificato il contesto di crittografia, puoi eliminare la sessione o riutilizzarla. Se è necessario riconfigurare la sessione, utilizzare il `aws_cryptosdk_session_reset` metodo.
```
aws_cryptosdk_session_destroy(session);
```