Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Kit SDK de chiffrement AWS pour C
Elle Kit SDK de chiffrement AWS pour C fournit une bibliothèque de chiffrement côté client pour les développeurs qui écrivent des applications en C. Elle sert également de base aux implémentations du AWS Encryption SDK dans les langages de programmation de niveau supérieur.
Comme toutes les implémentations du AWS Encryption SDK, il Kit SDK de chiffrement AWS pour C offre des fonctionnalités avancées de protection des données. Il s'agit notamment du [chiffrement d'enveloppe](concepts.md#envelope-encryption), de données authentifiées supplémentaires (données AAD) et de [suites d'algorithmes](concepts.md#crypto-algorithm) de clés symétriques sécurisées, authentifiées, comme les clés AES-GCM 256 bits avec dérivation de clés et signature.
Toutes les implémentations spécifiques au langage AWS Encryption SDK sont totalement interopérables. Par exemple, vous pouvez chiffrer des données avec le Kit SDK de chiffrement AWS pour C et les déchiffrer avec [n'importe quelle implémentation de langage prise en charge](programming-languages.md), y compris la [AWS CLI](crypto-cli.md) de chiffrement.
Kit SDK de chiffrement AWS pour C Cela nécessite AWS SDK pour C\$1\$1 d'interagir avec AWS Key Management Service (AWS KMS). Vous ne devez l'utiliser que si vous utilisez le [AWS KMS porte-clés](use-kms-keyring.md) en option. Cependant, aucun autre AWS service n'est requis AWS KMS . AWS Encryption SDK
**En savoir plus**
+ Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour C, consultez les [exemples en C](c-examples.md), les [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) et la [documentation de l'Kit SDK de chiffrement AWS pour C API](https://aws.github.io/aws-encryption-sdk-c/html/). GitHub
+ Pour savoir comment utiliser le pour chiffrer des données afin de les Kit SDK de chiffrement AWS pour C déchiffrer en plusieurs exemplaires Régions AWS, consultez la section [Comment déchiffrer des textes chiffrés dans plusieurs régions à l'aide du code AWS Encryption SDK en C du blog sur la sécurité](https://aws.amazon.com/blogs/security/how-to-decrypt-ciphertexts-multiple-regions-aws-encryption-sdk-in-c/). AWS
**Topics**
+ [Installation](c-language-installation.md)
+ [Utilisation du kit SDK C](c-language-using.md)
+ [Exemples](c-examples.md)
# Installation du Kit SDK de chiffrement AWS pour C
Installez la dernière version de Kit SDK de chiffrement AWS pour C.
**Note**
Toutes les versions Kit SDK de chiffrement AWS pour C antérieures à la version 2.0.0 sont en [end-of-supportphase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle).
Vous pouvez effectuer la mise à jour en toute sécurité à partir de la version 2.0. *x* et versions ultérieures vers la dernière version du Kit SDK de chiffrement AWS pour C sans aucune modification du code ou des données. Cependant, de [nouvelles fonctionnalités de sécurité](about-versions.md#version-2) ont été introduites dans la version 2.0. *x* ne sont pas rétrocompatibles. Pour effectuer une mise à jour à partir de versions antérieures à 1.7. *x* vers la version 2.0. *x* et versions ultérieures, vous devez d'abord effectuer la mise à jour vers la dernière version 1. version *x* du Kit SDK de chiffrement AWS pour C. Pour en savoir plus, consultez [Migration de votre AWS Encryption SDK](migration.md).
Vous trouverez des instructions détaillées pour l'installation et la création du Kit SDK de chiffrement AWS pour C dans le [fichier README](https://github.com/aws/aws-encryption-sdk-c/#readme) du [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)référentiel. Il inclut des instructions pour créer sur les plateformes Amazon Linux, Ubuntu, macOS et Windows.
Avant de commencer, décidez si vous souhaitez utiliser des [AWS KMS porte-clés](use-kms-keyring.md) dans le AWS Encryption SDK. Si vous utilisez un AWS KMS porte-clés, vous devez installer le AWS SDK pour C\$1\$1. Le AWS SDK est nécessaire pour interagir avec [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS). Lorsque vous utilisez des AWS KMS trousseaux de AWS Encryption SDK clés, ils génèrent et protègent les clés de chiffrement qui protègent vos données. AWS KMS
Vous n'avez pas besoin de l'installer AWS SDK pour C\$1\$1 si vous utilisez un autre type de trousseau de clés, tel qu'un trousseau de clés AES brut, un trousseau de clés RSA brut ou un trousseau de clés multiple qui n'inclut pas de trousseau de clés. AWS KMS Toutefois, lorsque vous utilisez un type de trousseau de clés brut, vous devez générer et protéger vos propres clés d'encapsulation brutes.
Si vous rencontrez des difficultés avec votre installation, [signalez le problème dans le `aws-encryption-sdk-c` référentiel ou utilisez l'un](https://github.com/aws/aws-encryption-sdk-c/issues) des liens de commentaires sur cette page.
# En utilisant le Kit SDK de chiffrement AWS pour C
Cette rubrique décrit certaines des fonctionnalités Kit SDK de chiffrement AWS pour C qui ne sont pas prises en charge dans d'autres implémentations de langages de programmation.
Les exemples présentés dans cette section montrent comment utiliser [la version 2.0. ](about-versions.md)*x* et versions ultérieures du Kit SDK de chiffrement AWS pour C. Pour les exemples utilisant des versions antérieures, recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-c/releases) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) sur GitHub.
Pour plus de détails sur la programmation avec le Kit SDK de chiffrement AWS pour C, consultez les [exemples en C](c-examples.md), les [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) et la [documentation de l'Kit SDK de chiffrement AWS pour C API](https://aws.github.io/aws-encryption-sdk-c/html/). GitHub
Voir aussi : [Porte-clés](choose-keyring.md)
**Topics**
+ [Modèles de chiffrement et de déchiffrement des données](#c-language-using-pattern)
+ [Comptage des références](#c-language-using-release)
## Modèles de chiffrement et de déchiffrement des données
Lorsque vous utilisez le Kit SDK de chiffrement AWS pour C, vous suivez un schéma similaire à celui-ci : créez un trousseau de [clés](concepts.md#keyring), créez un [CMM](concepts.md#crypt-materials-manager) qui utilise le trousseau de clés, créez une session qui utilise le CMM (et le trousseau de clés), puis traitez la session.
1. Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
2. Créez un porte-clés.
Configurez votre [porte-clés](concepts.md#keyring) avec les clés d'encapsulage que vous souhaitez utiliser pour chiffrer vos clés de données. Cet exemple utilise un [AWS KMS porte-clés avec un porte-clés](use-kms-keyring.md) AWS KMS key, mais vous pouvez utiliser n'importe quel type de porte-clés à sa place.
Pour identifier un élément AWS KMS key dans un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour C, spécifiez un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) ou un [alias ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Dans un porte-clés de déchiffrement, vous devez utiliser un ARN de clé. Pour en savoir plus, consultez [Identification AWS KMS keys dans un AWS KMS porte-clés](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. Créez une session.
Dans le Kit SDK de chiffrement AWS pour C, vous utilisez une *session* pour chiffrer un seul message en texte brut ou déchiffrer un seul message chiffré, quelle que soit sa taille. La session conserve l'état du message tout au long de son traitement.
Configurez votre session avec un allocateur, un porte-clés et un mode : `AWS_CRYPTOSDK_ENCRYPT` ou `AWS_CRYPTOSDK_DECRYPT`. Si vous devez modifier le mode de la session, utilisez la méthode `aws_cryptosdk_session_reset`.
Lorsque vous créez une session avec un trousseau de clés, un gestionnaire de matériel cryptographique (CMM) par défaut est Kit SDK de chiffrement AWS pour C automatiquement créé pour vous. Vous n'avez pas besoin de créer, de maintenir ou de détruire cet objet.
Par exemple, la session suivante utilise l'allocateur et le porte-clés qui a été défini à l'étape 1. Lorsque vous chiffrez des données, le mode est `AWS_CRYPTOSDK_ENCRYPT`.
```
struct aws_cryptosdk_session * session = aws_cryptosdk_session_new_from_keyring_2(allocator, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);
```
4. Chiffrez ou déchiffrez les données.
Pour traiter les données de la session, utilisez la méthode `aws_cryptosdk_session_process`. Si le tampon d'entrée est suffisamment grand pour contenir l'intégralité du texte en clair et que le tampon de sortie est suffisamment grand pour contenir l'intégralité du texte chiffré, vous pouvez appeler. `aws_cryptosdk_session_process_full` Toutefois, si vous devez gérer des données en streaming, vous pouvez effectuer un appel `aws_cryptosdk_session_process` en boucle. Pour de plus amples informations, vous pouvez consulter l'exemple [file\$1streaming.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/file_streaming.cpp). `aws_cryptosdk_session_process_full`Il est introduit dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x.*
Lorsque la session est configurée pour chiffrer des données, les champs de texte brut décrivent les champs d'entrée et les champs du texte chiffré décrivent la sortie. Le champ `plaintext` contient le message que vous souhaitez chiffrer et le champ `ciphertext` obtient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement
```
/* Encrypting data */
aws_cryptosdk_session_process_full(session,
ciphertext,
ciphertext_buffer_size,
&ciphertext_length,
plaintext,
plaintext_length)
```
Lorsque la session est configurée pour déchiffrer des données, les champs de texte chiffré décrivent les champs d'entrée et les champs du texte brut décrivent la sortie. Le champ `ciphertext` contient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement, et le champ `plaintext` obtient le message en texte brut renvoyé par la méthode de déchiffrement.
Pour déchiffrer les données, appelez la méthode `aws_cryptosdk_session_process_full`.
```
/* Decrypting data */
aws_cryptosdk_session_process_full(session,
plaintext,
plaintext_buffer_size,
&plaintext_length,
ciphertext,
ciphertext_length)
```
## Comptage des références
Pour éviter les fuites de mémoire, assurez-vous de libérer vos références à tous les objets que vous créez lorsque vous en avez terminé avec eux. Dans le cas contraire, des fuites de mémoire se produisent. Le kit SDK fournit des méthodes pour faciliter cette tâche.
Chaque fois que vous créez un objet parent avec l'un des objets enfants suivants, l'objet parent obtient et conserve une référence à l'objet enfant, comme suit :
+ Un [porte-clés](concepts.md#keyring), tel que la création d'une session avec un porte-clés
+ Un [gestionnaire de matériaux cryptographiques](concepts.md#crypt-materials-manager) (CMM) par défaut, tel que la création d'une session ou un CMM personnalisé avec un CMM par défaut
+ Un [cache de clés de données](data-key-caching.md), tel que la création d'un CMM de mise en cache avec un porte-clés et un cache
Sauf si vous avez besoin d'une référence indépendante à l'objet enfant, vous pouvez libérer votre référence à l'objet enfant dès que vous créez l'objet parent. La référence restante à l'objet enfant est libérée lorsque l'objet parent est détruit. Ce modèle garantit que vous conservez la référence à chaque objet uniquement pendant le délai nécessaire et empêche les fuites de mémoire en raison de références non libérées.
Vous êtes uniquement responsable de la libération des références aux objets enfants que vous créez explicitement. Vous n'êtes pas responsable de la gestion des références aux objets créés par le SDK pour vous. Si le SDK crée un objet, tel que le CMM par défaut que la `aws_cryptosdk_caching_cmm_new_from_keyring` méthode ajoute à une session, le SDK gère la création et la destruction de l'objet et de ses références.
Dans l'exemple suivant, lorsque vous créez une session avec un [porte-clés](concepts.md#keyring), la session obtient une référence au porte-clés et conserve cette référence jusqu'à ce que la session soit détruite. Si vous n'avez pas besoin de conserver une référence supplémentaire au porte-clés, vous pouvez utiliser la méthode `aws_cryptosdk_keyring_release` pour libérer l'objet de porte-clés dès que la session est créée. Cette méthode diminue le nombre de références pour le porte-clés. La référence de la session au porte-clés est libérée lorsque vous appelez `aws_cryptosdk_session_destroy` pour détruire la session.
```
// 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);
```
Pour les tâches plus complexes, telles que la réutilisation d'un trousseau de clés pour plusieurs sessions ou la spécification d'une suite d'algorithmes dans un CMM, vous devrez peut-être conserver une référence indépendante à l'objet. Si c'est le cas, n'appelez pas les méthodes de publication immédiatement. Au lieu de cela, libérez vos références lorsque vous n'utilisez plus les objets, en plus de détruire la session.
Cette technique de comptage de références fonctionne également lorsque vous utilisez une alternative CMMs, telle que le CMM de mise en cache pour la mise en cache [des clés de données](data-key-caching.md). Lorsque vous créez un CMM de mise en cache à partir d'un cache et d'un trousseau de clés, le CMM de mise en cache obtient une référence aux deux objets. À moins que vous n'en ayez besoin pour une autre tâche, vous pouvez libérer vos références indépendantes au cache et au trousseau de clés dès que le CMM de mise en cache est créé. Ensuite, lorsque vous créez une session avec le CMM de mise en cache, vous pouvez libérer votre référence au CMM de mise en cache.
Notez que vous êtes uniquement responsable de la publication des références aux objets que vous créez explicitement. Les objets que les méthodes créent pour vous, tels que le CMM par défaut qui sous-tend le CMM de mise en cache, sont gérés par la méthode.
```
/ 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);
```
# Kit SDK de chiffrement AWS pour C exemples
Les exemples suivants vous montrent comment utiliser le Kit SDK de chiffrement AWS pour C pour chiffrer et déchiffrer des données.
Les exemples présentés dans cette section montrent comment utiliser les versions 2.0. *x* et versions ultérieures du Kit SDK de chiffrement AWS pour C. Pour les exemples utilisant des versions antérieures, recherchez votre version dans la liste des [versions](https://github.com/aws/aws-encryption-sdk-c/releases) du [aws-encryption-sdk-c référentiel](https://github.com/aws/aws-encryption-sdk-c/) sur GitHub.
Lorsque vous installez et compilez le Kit SDK de chiffrement AWS pour C, le code source de ces exemples et d'autres exemples est inclus dans le `examples` sous-répertoire, puis compilé et intégré au `build` répertoire. Vous pouvez également les trouver dans le sous-répertoire des [exemples](https://github.com/aws/aws-encryption-sdk-c/tree/master/examples) du [aws-encryption-sdk-c](https://github.com/aws/aws-encryption-sdk-c/)référentiel sur GitHub.
**Topics**
+ [Chiffrement et déchiffrement de chaînes](#c-example-strings)
## Chiffrement et déchiffrement de chaînes
L'exemple suivant montre comment utiliser le Kit SDK de chiffrement AWS pour C pour chiffrer et déchiffrer une chaîne.
Cet exemple présente le [AWS KMS trousseau de clés](use-kms-keyring.md), un type de trousseau de clés qui utilise un AWS KMS key in [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/) pour générer et chiffrer des clés de données. L'exemple inclut du code écrit en C\$1\$1. Kit SDK de chiffrement AWS pour C Nécessite AWS SDK pour C\$1\$1 d'appeler AWS KMS lorsque vous utilisez un trousseau de AWS KMS clés. Si vous utilisez un trousseau de clés qui n'interagit pas avec AWS KMS, tel qu'un trousseau de clés AES brut, un trousseau de clés RSA brut ou un trousseau de clés multiple qui n'inclut pas de trousseau de clés, ce n'est pas obligatoire AWS KMS . AWS SDK pour C\$1\$1
Pour obtenir de l'aide sur la création d'un AWS KMS key, consultez la section [Création de clés](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) dans le *guide du AWS Key Management Service développeur*. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voir[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
**Consultez l'exemple de code complet** : [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/string.cpp)
**Topics**
+ [Chiffrement d'une chaîne](#c-example-string-encrypt)
+ [Déchiffrement d'une chaîne](#c-example-string-decrypt)
### Chiffrement d'une chaîne
La première partie de cet exemple utilise un AWS KMS trousseau de clés avec un AWS KMS key pour chiffrer une chaîne en texte brut.
Étape 1. Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Étape 2 : Construisez le porte-clés.
Créez un AWS KMS trousseau de clés pour le chiffrement. Dans cet exemple, le trousseau de clés est configuré avec un seul AWS KMS key, mais vous pouvez configurer un AWS KMS trousseau de clés avec plusieurs AWS KMS keys, y compris AWS KMS keys dans des comptes différents Régions AWS et différents.
Pour identifier un élément AWS KMS key dans un jeu de clés de chiffrement dans le Kit SDK de chiffrement AWS pour C, spécifiez un [ARN clé](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) ou un [alias ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn). Dans un porte-clés de déchiffrement, vous devez utiliser un ARN de clé. Pour en savoir plus, consultez [Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id)
Lorsque vous créez un jeu de clés comportant plusieurs clés AWS KMS keys, vous spécifiez le code AWS KMS key utilisé pour générer et chiffrer la clé de données en texte brut, ainsi qu'un tableau facultatif de clés supplémentaires AWS KMS keys qui chiffrent la même clé de données en texte brut. Dans ce cas, vous ne spécifiez que le générateur AWS KMS key.
Avant d'exécuter ce code, remplacez l'exemple d'ARN de clé par un ARN valide.
```
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);
```
Étape 3 : Création d'une session.
Créez une session à l'aide de l'allocateur, d'un énumérateur de mode et du porte-clés.
Chaque session nécessite un mode : soit `AWS_CRYPTOSDK_ENCRYPT` pour chiffrer, soit `AWS_CRYPTOSDK_DECRYPT` pour déchiffrer. Pour modifier le mode d'une session existante, utilisez la méthode `aws_cryptosdk_session_reset`.
Après avoir créé une session avec le porte-clés, vous pouvez libérer votre référence au porte-clés à l'aide de la méthode fournie par le kit SDK. La session conserve une référence à l'objet de porte-clés pendant sa durée de vie. Les références aux objets de porte-clés et de session sont libérées lorsque vous détruisez la session. Cette technique de [comptage de référence](c-language-using.md#c-language-using-release) permet d'éviter les fuites de mémoire et d'empêcher la libération des objets pendant leur utilisation.
```
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);
```
Étape 4 : Définition du contexte de chiffrement.
Un [contexte de chiffrement](concepts.md#encryption-context) est un ensemble de données authentifiées supplémentaires non secrètes et arbitraires. Lorsque vous fournissez un contexte de chiffrement sur Encrypt, le contexte de chiffrement lie AWS Encryption SDK cryptographiquement le contexte de chiffrement au texte chiffré afin que le même contexte de chiffrement soit requis pour déchiffrer les données. L'utilisation d'un contexte de chiffrement est facultative, mais nous vous le recommandons dans le cadre des bonnes pratiques.
Tout d'abord, créez une table de hachage qui inclut le contexte de chiffrement des chaînes.
```
/* 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)
```
Obtenez un pointeur réversible dans le contexte de chiffrement de la session. Ensuite, utilisez la fonction `aws_cryptosdk_enc_ctx_clone` pour copier le contexte de chiffrement dans la session. Conservez la copie dans `my_enc_ctx` afin de pouvoir valider la valeur après le déchiffrement des données.
Le contexte de chiffrement fait partie de la session. Il ne s'agit pas d'un paramètre transmis à la fonction du processus de session. Cela garantit que le même contexte de chiffrement est utilisé pour chaque segment d'un message, même si la fonction du processus de session est appelée plusieurs fois pour chiffrer l'intégralité du message.
```
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)
```
Étape 5 : Chiffrement de la chaîne.
Pour chiffrer la chaîne en texte brut, utilisez la méthode `aws_cryptosdk_session_process_full` avec la session dans le mode de chiffrement. Cette méthode, introduite dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x*, est conçu pour le chiffrement et le déchiffrement sans diffusion en continu. Pour gérer les données en streaming, appelez le `aws_cryptosdk_session_process` in a loop.
Lors du chiffrement, les champs de texte brut sont des champs d'entrée ; les champs de texte chiffré sont des champs de sortie. Une fois le traitement terminé, le champ `ciphertext_output` contient le [message chiffré](concepts.md#message), y compris le texte chiffré réel, des clés de données chiffrées et le contexte de chiffrement. Vous pouvez déchiffrer ce message crypté à l'aide de n'importe quel langage AWS Encryption SDK de programmation pris en charge.
```
/* 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;
}
```
Étape 6 : Nettoyage de la session.
La dernière étape détruit la session, y compris les références au CMM et au trousseau de clés.
Si vous préférez, au lieu de détruire la session, vous pouvez la réutiliser avec le même jeu de clés et le même CMM pour déchiffrer la chaîne, ou pour chiffrer ou déchiffrer d'autres messages. Pour utiliser la session pour le déchiffrement, utilisez la méthode `aws_cryptosdk_session_reset` pour modifier le mode vers `AWS_CRYPTOSDK_DECRYPT`.
### Déchiffrement d'une chaîne
La deuxième partie de cet exemple consiste à déchiffrer un message chiffré qui contient le texte chiffré de la chaîne d'origine.
Étape 1 : Chargez les chaînes d'erreur.
Appelez la `aws_cryptosdk_load_error_strings()` méthode dans votre code C ou C\$1\$1. Il charge des informations d'erreur très utiles pour le débogage.
Vous n'avez besoin de l'appeler qu'une seule fois, comme dans votre `main` méthode.
```
/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();
```
Étape 2 : Construisez le porte-clés.
Lorsque vous déchiffrez des données AWS KMS, vous transmettez le [message crypté renvoyé](concepts.md#message) par l'API de chiffrement. L'[API Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) ne prend pas d'entrée AWS KMS key AS. Il AWS KMS utilise plutôt le même code AWS KMS key pour déchiffrer le texte chiffré utilisé pour le chiffrer. Cependant, il vous AWS Encryption SDK permet de spécifier un AWS KMS trousseau de clés sans AWS KMS keys chiffrement ni déchiffrement.
Lors du déchiffrement, vous pouvez configurer un trousseau de clés contenant uniquement le code AWS KMS keys que vous souhaitez utiliser pour déchiffrer le message chiffré. Par exemple, vous souhaiterez peut-être créer un trousseau de clés contenant uniquement le AWS KMS key code utilisé par un rôle spécifique au sein de votre organisation. Ils n' AWS Encryption SDK utiliseront jamais un à AWS KMS key moins qu'il n'apparaisse dans le trousseau de clés de déchiffrement. Si le SDK ne parvient pas à déchiffrer les clés de données chiffrées AWS KMS keys à l'aide du trousseau de clés que vous fournissez, soit parce qu'aucun élément du jeu de AWS KMS keys clés n'a été utilisé pour chiffrer les clés de données, soit parce que l'appelant n'est pas autorisé à utiliser le trousseau de clés pour les déchiffrer, l' AWS KMS keys appel de déchiffrement échoue.
Lorsque vous spécifiez un AWS KMS key pour un trousseau de clés de déchiffrement, vous devez utiliser son [ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) clé. ARNsLes [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-arn) ne sont autorisés que dans les trousseaux de clés de chiffrement. Pour obtenir de l'aide pour identifier le AWS KMS keys contenu d'un AWS KMS trousseau de clés, voir[Identification AWS KMS keys dans un AWS KMS porte-clés](use-kms-keyring.md#kms-keyring-id).
Dans cet exemple, nous indiquons un trousseau de clés configuré avec le même que celui AWS KMS key utilisé pour chiffrer la chaîne. Avant d'exécuter ce code, remplacez l'exemple d'ARN de clé par un ARN valide.
```
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);
```
Étape 3 : Création d'une session.
Créez une session à l'aide de l'allocateur et du porte-clés. Pour configurer la session pour le déchiffrement, configurez la session avec le mode `AWS_CRYPTOSDK_DECRYPT`.
Après avoir créé une session avec un porte-clés, vous pouvez libérer votre référence au porte-clés à l'aide de la méthode fournie par le kit SDK. La session conserve une référence à l'objet de porte-clés pendant sa durée de vie, et la session et le porte-clés sont tous les deux libérés lorsque vous détruisez la session. Cette technique de comptage de référence permet d'éviter les fuites de mémoire et d'empêcher la libération des objets pendant leur utilisation.
```
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);
```
Étape 4 : Déchiffrement de la chaîne.
Pour déchiffrer la chaîne, utilisez la méthode `aws_cryptosdk_session_process_full` avec la session qui est configurée pour le déchiffrement. Cette méthode, introduite dans AWS Encryption SDK les versions 1.9. *x* et 2.2. *x*, est conçu pour le chiffrement et le déchiffrement sans diffusion en continu. Pour gérer les données en streaming, appelez le `aws_cryptosdk_session_process` in a loop.
Lors du déchiffrement, les champs de texte chiffré sont des champs d'entrée et les champs de texte brut sont des champs de sortie. Le champ `ciphertext_input` contient le [message chiffré](message-format.md) renvoyé par la méthode de chiffrement. Une fois le traitement terminé, le champ `plaintext_output` contient la chaîne en texte brut (déchiffrée).
```
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;
}
```
Étape 5 : Vérification du contexte de chiffrement.
Assurez-vous que le contexte de chiffrement réel, celui qui a été utilisé pour déchiffrer le message, contient le contexte de chiffrement que vous avez fourni lors du chiffrement du message. Le contexte de chiffrement réel peut inclure des paires supplémentaires. En effet, [le gestionnaire de matériaux cryptographiques](concepts.md#crypt-materials-manager) (CMM) peut ajouter des paires au contexte de chiffrement fourni avant de chiffrer le message.
Dans le Kit SDK de chiffrement AWS pour C, vous n'êtes pas obligé de fournir un contexte de chiffrement lors du déchiffrement, car le contexte de chiffrement est inclus dans le message chiffré renvoyé par le SDK. Toutefois, avant qu'elle ne renvoie le message en texte brut, votre fonction de déchiffrement doit vérifier que toutes les paires du contexte de chiffrement fourni apparaissent dans le contexte de chiffrement qui a été utilisé pour déchiffrer le message.
Tout d'abord, obtenez un pointeur en lecture seule à la table de hachage de la session. Cette table de hachage contient le contexte de chiffrement qui a été utilisé pour déchiffrer le message.
```
const struct aws_hash_table *session_enc_ctx = aws_cryptosdk_session_get_enc_ctx_ptr(session);
```
Ensuite, parcourez le contexte de chiffrement dans la table de hachage `my_enc_ctx` que vous avez copiée lors du chiffrement. Vérifiez que chaque paire de la table de hachage `my_enc_ctx` qui a été utilisée pour chiffrer s'affiche dans la table de hachage `session_enc_ctx` qui a été utilisée pour déchiffrer. Si une clé est manquante ou si cette clé a une valeur différente, arrêtez le traitement et écrivez un message d'erreur.
```
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();
}
}
```
Étape 6 : Nettoyage de la session.
Après avoir vérifié le contexte de chiffrement, vous pouvez détruire la session ou la réutiliser. Si vous devez reconfigurer la session, utilisez la `aws_cryptosdk_session_reset` méthode.
```
aws_cryptosdk_session_destroy(session);
```