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.
# AWS Encryption SDK référence
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Il AWS Encryption SDK utilise les [algorithmes pris en charge](supported-algorithms.md) pour renvoyer une structure de données ou un *message* unique contenant des données cryptées et les clés de données cryptées correspondantes. Les rubriques suivantes expliquent les algorithmes et la structure de données. Utilisez ces informations pour générer des bibliothèques qui peuvent lire et écrire des textes chiffrés compatibles avec ce kit SDK.
**Topics**
+ [Référence Format des messages du kit](message-format.md)
+ [Exemples de format des messages](message-format-examples.md)
+ [Référence données AAD du corps](body-aad-reference.md)
+ [Référence relative aux algorithmes du kit](algorithms-reference.md)
+ [Référence Vecteur d'initialisation du kit](IV-reference.md)
+ [AWS KMS Détails techniques du porte-clés hiérarchique](hierarchical-keyring-details.md)
# AWS Encryption SDK référence de format de message
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Les opérations de chiffrement AWS Encryption SDK renvoient une structure de données unique ou un [message chiffré](concepts.md#message) contenant les données chiffrées (texte chiffré) et toutes les clés de données chiffrées. Pour comprendre cette structure de données, ou pour créer des bibliothèques capables de la lire et de l'écrire, vous devez comprendre le format de message.
Le format de message se compose d'au moins deux parties : un *en-tête* et un *corps*. Dans certains cas, le format de message se compose d'une troisième partie, un *pied de page*. Le format de message définit une séquence ordonnée d'octets dans l’ordre des octets réseau, également appelé format de poids fort. Le format de message commence par l'en-tête, est suivi du corps, puis du pied de page (le cas échéant).
Les [suites d'algorithmes](algorithms-reference.md) prises en charge AWS Encryption SDK utilisent l'une des deux versions de format de message. Les suites d'algorithmes sans [engagement clé](concepts.md#key-commitment) utilisent le format de message version 1. Les suites d'algorithmes avec engagement clé utilisent le format de message version 2.
**Topics**
+ [Structure de l'en-tête](#header-structure)
+ [Structure du corps](#body-structure)
+ [Structure du pied de page](#footer-structure)
## Structure de l'en-tête
L'en-tête du message contient la clé de données chiffrée, ainsi que des informations sur la manière dont le corps du message est formé. Le tableau suivant décrit les champs qui constituent l'en-tête dans les versions 1 et 2 du format de message. Les octets sont ajoutés dans l'ordre indiqué.
La valeur **Non présent** indique que le champ n'existe pas dans cette version du format de message. **Le texte en gras** indique des valeurs différentes dans chaque version.
**Note**
Il peut être nécessaire de faire défiler horizontalement ou verticalement pour afficher toutes les données de ce tableau.
**Structure de l'en-tête**
| Champ | Format de message version 1Longueur (octets) | Format de message version 2Longueur (octets) |
| --- | --- | --- |
| [Version](#header-version) | 1 | 1 |
| [Type](#header-type) | 1 | Absent |
| [Algorithm ID](#header-algorithm-id) | 2 | 2 |
| [Message ID](#header-message-id) | 16 | 32 |
| [AAD Length](#header-aad-length) | 2Lorsque le [contexte de chiffrement](concepts.md#encryption-context) est vide, la valeur du champ AAD Length de 2 octets est 0. | 2Lorsque le [contexte de chiffrement](concepts.md#encryption-context) est vide, la valeur du champ AAD Length de 2 octets est 0. |
| [AAD](#header-aad) | Variable. La longueur de ce champ apparaît dans les 2 octets précédents (champ AAD Length). Lorsque le [contexte de chiffrement](concepts.md#encryption-context) est vide, il n'y a pas de champ AAD dans l'en-tête. | Variable. La longueur de ce champ apparaît dans les 2 octets précédents (champ AAD Length). Lorsque le [contexte de chiffrement](concepts.md#encryption-context) est vide, il n'y a pas de champ AAD dans l'en-tête. |
| [Encrypted Data Key Count](#header-data-key-count) | 2 | 2 |
| [Encrypted Data Key(s)](#header-data-keys) | Variable. Déterminé par le nombre de clés de données chiffrées et la longueur de chacune. | Variable. Déterminé par le nombre de clés de données chiffrées et la longueur de chacune. |
| [Content Type](#header-content-type) | 1 | 1 |
| [Reserved](#header-reserved) | 4 | Absent |
| [IV Length](#header-iv-length) | 1 | Absent |
| [Frame Length](#header-frame-length) | 4 | 4 |
| [Algorithm Suite Data](#algorithm-suite-data) | Absent | Variable. Déterminé par l'[algorithme](algorithms-reference.md) ayant généré le message. |
| [Header Authentication](#header-authentication) | Variable. Déterminé par l'[algorithme](algorithms-reference.md) ayant généré le message. | Variable. Déterminé par l'[algorithme](algorithms-reference.md) ayant généré le message. |
**Version**
Version de ce format de message. La version est codée en 1 ou 2 sous forme d'octet `01` ou `02` en notation hexadécimale
**Type**
Type de ce format de message. Le type indique le type de structure. Le seul type pris en charge est décrit comme *données chiffrées authentifiées client*. Sa valeur type est 128, codée en tant qu'octet `80`, au format hexadécimal.
Ce champ n'est pas présent dans le format de message version 2.
**ID de l'algorithme**
Identifiant de l'algorithme utilisé. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé. Pour plus d’informations sur ces algorithmes, consultez [AWS Encryption SDK référence aux algorithmes](algorithms-reference.md).
**ID du message**
Une valeur générée de manière aléatoire qui identifie le message. L'ID de message :
+ identifie de façon unique le message chiffré ;
+ lie faiblement l'en-tête du message au corps du message ;
+ fournit un mécanisme pour réutiliser une clé de données en toute sécurité avec plusieurs messages chiffrés ;
+ protège contre la réutilisation accidentelle d'une clé de données ou l'épuisement des clés dans le kit AWS Encryption SDK.
Cette valeur est de 128 bits dans le format de message version 1 et de 256 bits dans la version 2.
**Longueur AAD**
Longueur des données authentifiées supplémentaires (données AAD). Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent les données AAD.
Lorsque le [contexte de chiffrement](concepts.md#encryption-context) est vide, la valeur du champ AAD Length est 0.
**AAD**
Données authentifiées supplémentaires. Les données AAD constituent un encodage du [contexte de chiffrement](concepts.md#encryption-context), un tableau de paires clé-valeur dans lequel chaque clé et valeur est une chaîne de caractères codés UTF-8. Le contexte de chiffrement est converti en une séquence d'octets et utilisé pour la valeur AAD. Lorsque le contexte de chiffrement est vide, il n'y a pas de champ AAD dans l'en-tête.
Lorsque les [algorithmes de signature](algorithms-reference.md) sont utilisés, le contexte de chiffrement doit contenir la paire clé-valeur `{'aws-crypto-public-key', Qtxt}`. Qtxt représente le point Q de la courbe elliptique compressé conformément à [SEC 1 version 2.0](http://www.secg.org/sec1-v2.pdf), puis codé en base64. Le contexte de chiffrement peut contenir des valeurs supplémentaires, mais la longueur maximale des données AAD construites est 2^16 - 1 octets.
Le tableau suivant décrit les champs qui composent les données AAD. Les paires clé-valeur sont triées, par clé, en ordre croissant d'après le code caractère UTF-8. Les octets sont ajoutés dans l'ordre indiqué.
**Structure AAD**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/encryption-sdk/latest/developer-guide/message-format.html)
**Nombre de paires clé-valeur**
Nombre de paires clé-valeur dans les données AAD. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre de paires clé-valeur dans les données AAD. Le nombre maximum de paires clé-valeur dans les données AAD est 2^16 - 1.
Lorsqu'il n'y a pas de contexte de chiffrement ou si le contexte de chiffrement est vide, ce champ n'est pas présent dans la structure AAD.
**Longueur de la clé**
Longueur de la clé pour la paire clé-valeur. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent la clé.
**Clé**
Clé de la paire clé-valeur. Il s'agit d'une séquence d'octets codés en UTF-8.
**Longueur de la valeur**
Longueur de la valeur pour la paire clé-valeur. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent la valeur.
**Valeur**
Valeur de la paire clé-valeur. Il s'agit d'une séquence d'octets codés en UTF-8.
**Nombre de clés de données cryptées**
Nombre de clés de données chiffrées. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre de clés de données chiffrées. Le nombre maximum de clés de données chiffrées dans chaque message est de 65 535 (2^16 - 1).
**Clé (s) de données cryptée (s)**
Séquence de clés de données chiffrées. La longueur de la séquence est déterminée par le nombre de clés de données chiffrées et la longueur de chacune. La séquence contient au moins une clé de données chiffrée.
Le tableau suivant décrit les champs qui composent chaque clé de données chiffrée. Les octets sont ajoutés dans l'ordre indiqué.
**Structure de la clé de données chiffrée**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/encryption-sdk/latest/developer-guide/message-format.html)
**Longueur de l'identifiant du fournisseur clé**
Longueur de l'identifiant du fournisseur de clés. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent l'ID du fournisseur des clés.
**Identifiant du fournisseur clé**
Identifiant du fournisseur de clés. Il est utilisé pour indiquer le fournisseur de la clé de données chiffrée et doit être extensible.
**Longueur des informations sur les fournisseurs clés**
Longueur de l'information du fournisseur de clés. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent l'information du fournisseur des clés.
**Informations clés sur les fournisseurs**
Information sur le fournisseur de clés. Il est déterminé par le fournisseur de clés.
Lorsqu'il AWS KMS s'agit du fournisseur de la clé principale ou que vous utilisez un AWS KMS trousseau de clés, cette valeur contient le Amazon Resource Name (ARN) du AWS KMS key.
**Longueur de la clé de données cryptée**
Longueur de la clé de données chiffrée. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent la clé de données chiffrée.
**Clé de données cryptée**
Clé de données chiffrée. Il s'agit de la clé de chiffrement des données chiffrée par le fournisseur de clés.
**Type de contenu**
Type de données chiffrées, non encadrées ou encadrées.
Dans la mesure du possible, utilisez des données encadrées. Il AWS Encryption SDK prend en charge les données non encadrées uniquement pour une utilisation traditionnelle. Certaines implémentations linguistiques du AWS Encryption SDK peuvent toujours générer du texte chiffré non encadré. Toutes les implémentations linguistiques prises en charge peuvent déchiffrer le texte chiffré encadré et non cadré.
Les données encadrées sont divisées en parties de même longueur ; chaque partie est cryptée séparément. Le type du contenu encadré est 2, codé en tant qu'octet `02` au format hexadécimal.
Les données non encadrées ne sont pas divisées ; il s'agit d'un seul blob chiffré. Le type du contenu non encadré est 1, codé en tant qu'octet `01` au format hexadécimal.
**Réservé**
Séquence réservée de 4 octets. La valeur doit être 0. Elle est codée en tant qu'octets `00 00 00 00` en notation hexadécimale (c'est-à-dire, une séquence de 4 octets d'une valeur d'entier 32 bits égale à 0).
Ce champ n'est pas présent dans le format de message version 2.
**Longueur IV**
Longueur du vecteur d'initialisation. Il s'agit d'une valeur de 1 octet interprétée comme un entier 8 bits non signé qui spécifie le nombre d'octets qui contiennent le vecteur d'initialisation. Cette valeur est déterminée par la valeur d'octets du vecteur d'initialisation de l'[algorithme](algorithms-reference.md) qui a généré le message.
Ce champ n'est pas présent dans la version 2 du format de message, qui prend uniquement en charge les suites d'algorithmes utilisant des valeurs IV déterministes dans l'en-tête du message.
**Longueur du cadre**
La longueur de chaque trame de données encadrées. Il s'agit d'une valeur de 4 octets interprétée comme un entier non signé de 32 bits qui indique le nombre d'octets dans chaque trame. Lorsque les données ne sont pas encadrées, c'est-à-dire lorsque la valeur du `Content Type` champ est 1, cette valeur doit être 0.
Dans la mesure du possible, utilisez des données encadrées. Il AWS Encryption SDK prend en charge les données non encadrées uniquement pour une utilisation traditionnelle. Certaines implémentations linguistiques du AWS Encryption SDK peuvent toujours générer du texte chiffré non encadré. Toutes les implémentations linguistiques prises en charge peuvent déchiffrer le texte chiffré encadré et non cadré.
**Données de la suite d'algorithmes**
Données supplémentaires nécessaires à l'[algorithme](algorithms-reference.md) qui a généré le message. La longueur et le contenu sont déterminés par l'algorithme. Sa longueur peut être de 0.
Ce champ n'est pas présent dans le format de message version 1.
**Authentification d'en-tête**
L'authentification de l'en-tête est déterminée par l'[algorithme](algorithms-reference.md) qui a généré le message. L'authentification de l'en-tête est calculée sur l'ensemble de l'en-tête. Elle se compose d'un vecteur d'initialisation et d'une balise d'authentification. Les octets sont ajoutés dans l'ordre indiqué.
**Structure de l'authentification de l'en-tête**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/encryption-sdk/latest/developer-guide/message-format.html)
**IV**
Vecteur d'initialisation utilisé pour calculer la balise d'authentification de l'en-tête.
Ce champ n'est pas présent dans l'en-tête du format de message version 2. La version 2 du format de message ne prend en charge que les suites d'algorithmes qui utilisent des valeurs IV déterministes dans l'en-tête du message.
**Tag d'authentification**
Valeur d'authentification pour l'en-tête. Elle est utilisée pour authentifier l'ensemble du contenu de l'en-tête.
## Structure du corps
Le corps du message contient les données chiffrées, appelées *texte chiffré*. La structure du corps dépend du type de contenu (non encadré ou encadré). Les sections suivantes décrivent le format du corps du message pour chaque type de contenu. La structure du corps du message est la même dans les versions 1 et 2 du format de message.
**Topics**
+ [Données non encadrées](#body-no-framing)
+ [Données encadrées](#body-framing)
### Données non encadrées
Les données non encadrées sont chiffrées dans un objet blob unique avec un vecteur d'initialisation et des [données de corps](body-aad-reference.md) uniques.
**Note**
Dans la mesure du possible, utilisez des données encadrées. Il AWS Encryption SDK prend en charge les données non encadrées uniquement pour une utilisation traditionnelle. Certaines implémentations linguistiques du AWS Encryption SDK peuvent toujours générer du texte chiffré non encadré. Toutes les implémentations linguistiques prises en charge peuvent déchiffrer le texte chiffré encadré et non cadré.
Le tableau suivant décrit les champs qui composent les données non encadrées. Les octets sont ajoutés dans l'ordre indiqué.
**Structure du corps non encadré**
| Champ | Longueur, en octets |
| --- | --- |
| [IV](#body-unframed-iv) | Variable. Est égal à la valeur spécifiée dans l'octet [IV Length](#header-iv-length) de l'en-tête. |
| [Encrypted Content Length](#body-unframed-content-length) | 8 |
| [Encrypted Content](#body-unframed-content) | Variable. Est égal à la valeur spécifiée dans les 8 octets précédents (Longueur du contenu chiffré). |
| [Authentication Tag](#body-unframed-tag) | Variable. Déterminé par l'[implémentation d'algorithme](algorithms-reference.md) utilisée. |
**IV**
Vecteur d'initialisation à utiliser avec l'[algorithme de chiffrement](algorithms-reference.md).
**Longueur du contenu crypté**
Longueur du contenu chiffré, ou *texte chiffré*. Il s'agit d'une valeur de 8 octets interprétée comme un entier 64 bits non signé qui spécifie le nombre d'octets qui contiennent le contenu chiffré.
Techniquement, la valeur maximale autorisée est de 2^63 - 1, ou 8 exbioctets (8 Eio). Toutefois, dans la pratique, la valeur maximale est de 2^36 - 32, ou 64 gibioctets (64 Gio), en raison des restrictions imposées par les [algorithmes implémentés](algorithms-reference.md).
L'implémentation Java de ce kit SDK limite encore cette valeur à 2^31 - 1, ou 2 gibioctets (2 Gio), en raison des restrictions du langage.
**Contenu crypté**
Contenu chiffré (texte chiffré), tel que renvoyé par l'[algorithme de chiffrement](algorithms-reference.md).
**Tag d'authentification**
Valeur d'authentification pour le corps. Elle est utilisée pour authentifier le corps du message.
### Données encadrées
Dans les données encadrées, les données en texte brut sont divisées en parties de longueur égale appelées *trames*. Il AWS Encryption SDK chiffre chaque image séparément avec un IV et un [corps AAD](body-aad-reference.md) uniques.
**Note**
Dans la mesure du possible, utilisez des données encadrées. Il AWS Encryption SDK prend en charge les données non encadrées uniquement pour une utilisation traditionnelle. Certaines implémentations linguistiques du AWS Encryption SDK peuvent toujours générer du texte chiffré non encadré. Toutes les implémentations linguistiques prises en charge peuvent déchiffrer le texte chiffré encadré et non cadré.
La [longueur du cadre](#header-frame-length), qui est la longueur du [contenu chiffré](#body-framed-regular-content) dans le cadre, peut être différente pour chaque message. Le nombre maximal d'octets dans une trame est de 2^32 - 1. Le nombre maximal d'images dans un message est de 2^32 - 1.
Il existe deux types de cadres : *régulier* et *final*. Chaque message doit comporter ou inclure une image finale.
Toutes les images régulières d'un message ont la même longueur d'image. Le cadre final peut avoir une longueur de cadre différente.
La composition des cadres dans les données encadrées varie en fonction de la longueur du contenu chiffré.
+ **Égal à la longueur de trame** — Lorsque la longueur du contenu chiffré est identique à celle des trames normales, le message peut consister en une trame normale contenant les données, suivie d'une trame finale de longueur nulle (0). Ou bien, le message peut être composé d'un seul cadre final contenant les données. Dans ce cas, le cadre final a la même longueur de cadre que les cadres normaux.
+ **Multiple de la longueur de trame** — Lorsque la longueur du contenu chiffré est un multiple exact de la longueur d'image des trames normales, le message peut se terminer par une trame normale contenant les données, suivie d'une trame finale de longueur nulle (0). Ou bien, le message peut se terminer dans un cadre final contenant les données. Dans ce cas, le cadre final a la même longueur de cadre que les cadres normaux.
+ **Pas un multiple de la longueur d'image** — Lorsque la longueur du contenu chiffré n'est pas un multiple exact de la longueur d'image des images normales, la dernière image contient les données restantes. La longueur du cadre final est inférieure à la longueur de cadre des cadres normaux.
+ **Moins que la longueur de trame** — Lorsque la longueur du contenu chiffré est inférieure à la longueur de trame des trames normales, le message consiste en une trame finale contenant toutes les données. La longueur du cadre final est inférieure à la longueur de cadre des cadres normaux.
Les tableaux suivants décrivent les champs qui composent les cadres. Les octets sont ajoutés dans l'ordre indiqué.
**Structure de corps encadré, cadre régulier**
| Champ | Longueur, en octets |
| --- | --- |
| [Sequence Number](#body-framed-regular-sequence-number) | 4 |
| [IV](#body-framed-regular-iv) | Variable. Est égal à la valeur spécifiée dans l'octet [IV Length](#header-iv-length) de l'en-tête. |
| [Encrypted Content](#body-framed-regular-content) | Variable. Est égal à la valeur spécifiée dans le [Frame Length](#header-frame-length) de l'en-tête. |
| [Authentication Tag](#body-framed-regular-tag) | Variable. Déterminé par l'algorithme utilisé, comme spécifié dans le [Algorithm ID](#header-algorithm-id) de l'en-tête. |
**Numéro de séquence**
Numéro de séquence du cadre. Il s'agit d'un numéro du compteur incrémentiel pour le cadre. Il s'agit d'une valeur de 4 octets interprétée comme un entier 32 bits non signé.
Les données encadrées doivent démarrer au numéro de séquence 1. Les cadres suivants doivent être dans l'ordre et doivent être incrémentés de 1 par rapport au cadre précédent. Dans le cas contraire, le processus de déchiffrement s'arrête et indique une erreur.
**IV**
Vecteur d'initialisation du cadre. Le kit SDK utilise une méthode déterministe pour construire un vecteur d'initialisation différent pour chaque image du message. Sa longueur est spécifiée par la [suite d'algorithmes](algorithms-reference.md) utilisée.
**Contenu crypté**
Contenu chiffré (texte chiffré) du cadre, tel que renvoyé par l'[algorithme de chiffrement](algorithms-reference.md).
**Tag d'authentification**
Valeur d'authentification pour le cadre. Elle est utilisée pour authentifier l'ensemble du cadre.
**Structure de corps encadré, cadre final**
| Champ | Longueur, en octets |
| --- | --- |
| [Sequence Number End](#body-framed-final-sequence-number-end) | 4 |
| [Sequence Number](#body-framed-final-sequence-number) | 4 |
| [IV](#body-framed-final-iv) | Variable. Est égal à la valeur spécifiée dans l'octet [IV Length](#header-iv-length) de l'en-tête. |
| [Encrypted Content Length](#body-framed-final-content-length) | 4 |
| [Encrypted Content](#body-framed-final-content) | Variable. Est égal à la valeur spécifiée dans les 4 octets précédents (Longueur du contenu chiffré). |
| [Authentication Tag](#body-framed-final-tag) | Variable. Déterminé par l'algorithme utilisé, comme spécifié dans le [Algorithm ID](#header-algorithm-id) de l'en-tête. |
**Fin du numéro de séquence**
Indicateur pour le dernier cadre. La valeur est codée en tant que 4 octets `FF FF FF FF` au format hexadécimal.
**Numéro de séquence**
Numéro de séquence du cadre. Il s'agit d'un numéro du compteur incrémentiel pour le cadre. Il s'agit d'une valeur de 4 octets interprétée comme un entier 32 bits non signé.
Les données encadrées doivent démarrer au numéro de séquence 1. Les cadres suivants doivent être dans l'ordre et doivent être incrémentés de 1 par rapport au cadre précédent. Dans le cas contraire, le processus de déchiffrement s'arrête et indique une erreur.
**IV**
Vecteur d'initialisation du cadre. Le kit SDK utilise une méthode déterministe pour construire un vecteur d'initialisation différent pour chaque image du message. La longueur du vecteur d'initialisation est spécifiée par la [suite d'algorithmes](algorithms-reference.md).
**Longueur du contenu crypté**
Longueur du contenu chiffré. Il s'agit d'une valeur de 4 octets interprétée comme un entier 32 bits non signé qui spécifie le nombre d'octets qui contiennent le contenu chiffré pour le cadre.
**Contenu crypté**
Contenu chiffré (texte chiffré) du cadre, tel que renvoyé par l'[algorithme de chiffrement](algorithms-reference.md).
**Tag d'authentification**
Valeur d'authentification pour le cadre. Elle est utilisée pour authentifier l'ensemble du cadre.
## Structure du pied de page
Lorsque les [algorithmes de signature](algorithms-reference.md) sont utilisés, le format de message contient un pied de page. Le pied de page du message contient une [signature numérique](concepts.md#digital-sigs) calculée sur l'en-tête et le corps du message. Le tableau suivant décrit les champs qui composent le pied de page. Les octets sont ajoutés dans l'ordre indiqué. La structure du pied de page du message est identique dans les versions 1 et 2 du format de message.
**Structure du pied de page**
| Champ | Longueur, en octets |
| --- | --- |
| [Signature Length](#footer-signature-length) | 2 |
| [Signature](#footer-signature) | Variable. Est égal à la valeur spécifiée dans les 2 octets précédents (Longueur de signature). |
**Durée de la signature**
Longueur de la signature. Il s'agit d'une valeur de 2 octets interprétée comme un entier 16 bits non signé qui spécifie le nombre d'octets qui contiennent la signature.
**Signature**
Signature.
# AWS Encryption SDK exemples de format de message
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Les rubriques suivantes présentent des exemples de format de AWS Encryption SDK message. Chaque exemple illustre les octets bruts, au format hexadécimal, suivis d'une description de ce que ces octets représentent.
**Topics**
+ [Données encadrées (format de message version 1)](#example-framed)
+ [Données encadrées (format de message version 2)](#example-framed-2)
+ [Données non encadrées (format de message version 1)](#example-nonframed)
## Données encadrées (format de message version 1)
L'exemple suivant montre le format de message pour les données encadrées dans le [format de message version 1](message-format.md).
```
+--------+
| Header |
+--------+
01 Version (1.0)
80 Type (128, customer authenticated encrypted data)
0378 Algorithm ID (see Référence relative aux algorithmes du kit)
6E7C0FBD 4DF4A999 717C22A2 DDFE1A27 Message ID (random 128-bit value)
008E AAD Length (142)
0004 AAD Key-Value Pair Count (4)
0005 AAD Key-Value Pair 1, Key Length (5)
30746869 73 AAD Key-Value Pair 1, Key ("0This")
0002 AAD Key-Value Pair 1, Value Length (2)
6973 AAD Key-Value Pair 1, Value ("is")
0003 AAD Key-Value Pair 2, Key Length (3)
31616E AAD Key-Value Pair 2, Key ("1an")
000A AAD Key-Value Pair 2, Value Length (10)
656E6372 79774690 6F6E AAD Key-Value Pair 2, Value ("encryption")
0008 AAD Key-Value Pair 3, Key Length (8)
32636F6E 74657874 AAD Key-Value Pair 3, Key ("2context")
0007 AAD Key-Value Pair 3, Value Length (7)
6578616D 706C65 AAD Key-Value Pair 3, Value ("example")
0015 AAD Key-Value Pair 4, Key Length (21)
6177732D 63727970 746F2D70 75626C69 AAD Key-Value Pair 4, Key ("aws-crypto-public-key")
632D6B65 79
0044 AAD Key-Value Pair 4, Value Length (68)
416A4173 7569326F 7430364C 4B77715A AAD Key-Value Pair 4, Value ("AjAsui2ot06LKwqZXDJnU/Aqc2vD+0OkpOZ1cc8Tg2qd7rs5aLTg7lvfUEW/86+/5w==")
58444A6E 552F4171 63327644 2B304F6B
704F5A31 63633854 67327164 37727335
614C5467 376C7666 5545572F 38362B2F
35773D3D
0002 EncryptedDataKeyCount (2)
0007 Encrypted Data Key 1, Key Provider ID Length (7)
6177732D 6B6D73 Encrypted Data Key 1, Key Provider ID ("aws-kms")
004B Encrypted Data Key 1, Key Provider Information Length (75)
61726E3A 6177733A 6B6D733A 75732D77 Encrypted Data Key 1, Key Provider Information ("arn:aws:kms:us-west-2:111122223333:key/715c0818-5825-4245-a755-138a6d9a11e6")
6573742D 323A3131 31313232 32323333
33333A6B 65792F37 31356330 3831382D
35383235 2D343234 352D6137 35352D31
33386136 64396131 316536
00A7 Encrypted Data Key 1, Encrypted Data Key Length (167)
01010200 7857A1C1 F7370545 4ECA7C83 Encrypted Data Key 1, Encrypted Data Key
956C4702 23DCE8D7 16C59679 973E3CED
02A4EF29 7F000000 7E307C06 092A8648
86F70D01 0706A06F 306D0201 00306806
092A8648 86F70D01 0701301E 06096086
48016503 04012E30 11040C3F F02C897B
7A12EB19 8BF2D802 0110803B 24003D1F
A5474FBC 392360B5 CB9997E0 6A17DE4C
A6BD7332 6BF86DAB 60D8CCB8 8295DBE9
4707E356 ADA3735A 7C52D778 B3135A47
9F224BF9 E67E87
0007 Encrypted Data Key 2, Key Provider ID Length (7)
6177732D 6B6D73 Encrypted Data Key 2, Key Provider ID ("aws-kms")
004E Encrypted Data Key 2, Key Provider Information Length (78)
61726E3A 6177733A 6B6D733A 63612D63 Encrypted Data Key 2, Key Provider Information ("arn:aws:kms:ca-central-1:111122223333:key/9b13ca4b-afcc-46a8-aa47-be3435b423ff")
656E7472 616C2D31 3A313131 31323232
32333333 333A6B65 792F3962 31336361
34622D61 6663632D 34366138 2D616134
372D6265 33343335 62343233 6666
00A7 Encrypted Data Key 2, Encrypted Data Key Length (167)
01010200 78FAFFFB D6DE06AF AC72F79B Encrypted Data Key 2, Encrypted Data Key
0E57BD87 3F60F4E6 FD196144 5A002C94
AF787150 69000000 7E307C06 092A8648
86F70D01 0706A06F 306D0201 00306806
092A8648 86F70D01 0701301E 06096086
48016503 04012E30 11040C36 CD985E12
D218B674 5BBC6102 0110803B 0320E3CD
E470AA27 DEAB660B 3E0CE8E0 8B1A89E4
57DCC69B AAB1294F 21202C01 9A50D323
72EBAAFD E24E3ED8 7168E0FA DB40508F
556FBD58 9E621C
02 Content Type (2, framed data)
00000000 Reserved
0C IV Length (12)
00000100 Frame Length (256)
4ECBD5C0 9899CA65 923D2347 IV
0B896144 0CA27950 CA571201 4DA58029 Authentication Tag
+------+
| Body |
+------+
00000001 Frame 1, Sequence Number (1)
6BD3FE9C ADBCB213 5B89E8F1 Frame 1, IV
1F6471E0 A51AF310 10FA9EF6 F0C76EDF Frame 1, Encrypted Content
F5AFA33C 7D2E8C6C 9C5D5175 A212AF8E
FBD9A0C3 C6E3FB59 C125DBF2 89AC7939
BDEE43A8 0F00F49E ACBBD8B2 1C785089
A90DB923 699A1495 C3B31B50 0A48A830
201E3AD9 1EA6DA14 7F6496DB 6BC104A4
DEB7F372 375ECB28 9BF84B6D 2863889F
CB80A167 9C361C4B 5EC07438 7A4822B4
A7D9D2CC 5150D414 AF75F509 FCE118BD
6D1E798B AEBA4CDB AD009E5F 1A571B77
0041BC78 3E5F2F41 8AF157FD 461E959A
BB732F27 D83DC36D CC9EBC05 00D87803
57F2BB80 066971C2 DEEA062F 4F36255D
E866C042 E1382369 12E9926B BA40E2FC
A820055F FB47E428 41876F14 3B6261D9
5262DB34 59F5D37E 76E46522 E8213640
04EE3CC5 379732B5 F56751FA 8E5F26AD Frame 1, Authentication Tag
00000002 Frame 2, Sequence Number (2)
F1140984 FF25F943 959BE514 Frame 2, IV
216C7C6A 2234F395 F0D2D9B9 304670BF Frame 2, Encrypted Content
A1042608 8A8BCB3F B58CF384 D72EC004
A41455B4 9A78BAC9 36E54E68 2709B7BD
A884C1E1 705FF696 E540D297 446A8285
23DFEE28 E74B225A 732F2C0C 27C6BDA2
7597C901 65EF3502 546575D4 6D5EBF22
1FF787AB 2E38FD77 125D129C 43D44B96
778D7CEE 3C36625F FF3A985C 76F7D320
ED70B1F3 79729B47 E7D9B5FC 02FCE9F5
C8760D55 7779520A 81D54F9B EC45219D
95941F7E 5CBAEAC8 CEC13B62 1464757D
AC65B6EF 08262D74 44670624 A3657F7F
2A57F1FD E7060503 AC37E197 2F297A84
DF1172C2 FA63CF54 E6E2B9B6 A86F582B
3B16F868 1BBC5E4D 0B6919B3 08D5ABCF
FECDC4A4 8577F08B 99D766A1 E5545670
A61F0A3B A3E45A84 4D151493 63ECA38F Frame 2, Authentication Tag
FFFFFFFF Final Frame, Sequence Number End
00000003 Final Frame, Sequence Number (3)
35F74F11 25410F01 DD9E04BF Final Frame, IV
0000008E Final Frame, Encrypted Content Length (142)
F7A53D37 2F467237 6FBD0B57 D1DFE830 Final Frame, Encrypted Content
B965AD1F A910AA5F 5EFFFFF4 BC7D431C
BA9FA7C4 B25AF82E 64A04E3A A0915526
88859500 7096FABB 3ACAD32A 75CFED0C
4A4E52A3 8E41484D 270B7A0F ED61810C
3A043180 DF25E5C5 3676E449 0986557F
C051AD55 A437F6BC 139E9E55 6199FD60
6ADC017D BA41CDA4 C9F17A83 3823F9EC
B66B6A5A 80FDB433 8A48D6A4 21CB
811234FD 8D589683 51F6F39A 040B3E3B Final Frame, Authentication Tag
+--------+
| Footer |
+--------+
0066 Signature Length (102)
30640230 085C1D3C 63424E15 B2244448 Signature
639AED00 F7624854 F8CF2203 D7198A28
758B309F 5EFD9D5D 2E07AD0B 467B8317
5208B133 02301DF7 2DFC877A 66838028
3C6A7D5E 4F8B894E 83D98E7C E350F424
7E06808D 0FE79002 E24422B9 98A0D130
A13762FF 844D
```
## Données encadrées (format de message version 2)
L'exemple suivant montre le format de message pour les données encadrées dans le [format de message version 2](message-format.md).
```
+--------+
| Header |
+--------+
02 Version (2.0)
0578 Algorithm ID (see Algorithms reference)
122747eb 21dfe39b 38631c61 7fad7340
cc621a30 32a11cc3 216d0204 fd148459 Message ID (random 256-bit value)
008e AAD Length (142)
0004 AAD Key-Value Pair Count (4)
0005 AAD Key-Value Pair 1, Key Length (5)
30546869 73 AAD Key-Value Pair 1, Key ("0This")
0002 AAD Key-Value Pair 1, Value Length (2)
6973 AAD Key-Value Pair 1, Value ("is")
0003 AAD Key-Value Pair 2, Key Length (3)
31616e AAD Key-Value Pair 2, Key ("1an")
000a AAD Key-Value Pair 2, Value Length (10)
656e6372 79707469 6f6e AAD Key-Value Pair 2, Value ("encryption")
0008 AAD Key-Value Pair 3, Key Length (8)
32636f6e 74657874 AAD Key-Value Pair 3, Key ("2context")
0007 AAD Key-Value Pair 3, Value Length (7)
6578616d 706c65 AAD Key-Value Pair 3, Value ("example")
0015 AAD Key-Value Pair 4, Key Length (21)
6177732d 63727970 746f2d70 75626c69 AAD Key-Value Pair 4, Key ("aws-crypto-public-key")
632d6b65 79
0044 AAD Key-Value Pair 4, Value Length (68)
41746733 72703845 41345161 36706669 AAD Key-Value Pair 4, Value ("QXRnM3JwOEVBNFFhNnBmaTk3MUlTNTk3NHpOMnlZWE5vSmtwRHFPc0dIYkVaVDRqME5OMlFkRStmbTFVY01WdThnPT0=")
39373149 53353937 347a4e32 7959584e
6f4a6b70 44714f73 47486245 5a54346a
304e4e32 5164452b 666d3155 634d5675
38673d3d
0001 Encrypted Data Key Count (1)
0007 Encrypted Data Key 1, Key Provider ID Length (7)
6177732d 6b6d73 Encrypted Data Key 1, Key Provider ID ("aws-kms")
004b Encrypted Data Key 1, Key Provider Information Length (75)
61726e3a 6177733a 6b6d733a 75732d77 Encrypted Data Key 1, Key Provider Information ("arn:aws:kms:us-west-2:658956600833:key/b3537ef1-d8dc-4780-9f5a-55776cbb2f7f")
6573742d 323a3635 38393536 36303038
33333a6b 65792f62 33353337 6566312d
64386463 2d343738 302d3966 35612d35
35373736 63626232 663766
00a7 Encrypted Data Key 1, Encrypted Data Key Length (167)
01010100 7840f38c 275e3109 7416c107 Encrypted Data Key 1, Encrypted Data Key
29515057 1964ada3 ef1c21e9 4c8ba0bd
bc9d0fb4 14000000 7e307c06 092a8648
86f70d01 0706a06f 306d0201 00306806
092a8648 86f70d01 0701301e 06096086
48016503 04012e30 11040c39 32d75294
06063803 f8460802 0110803b 2a46bc23
413196d2 903bf1d7 3ed98fc8 a94ac6ed
e00ee216 74ec1349 12777577 7fa052a5
ba62e9e4 f2ac8df6 bcb1758f 2ce0fb21
cc9ee5c9 7203bb
02 Content Type (2, framed data)
00001000 Frame Length (4096)
05cd035b 29d5499d 4587570b 87502afe Algorithm Suite Data (key commitment)
634f7b2c c3df2aa9 88a10105 4a2c7687
76cb339f 2536741f 59a1c202 4f2594ab Authentication Tag
+------+
| Body |
+------+
ffffffff Final Frame, Sequence Number End
00000001 Final Frame, Sequence Number (1)
00000000 00000000 00000001 Final Frame, IV
00000009 Final Frame, Encrypted Content Length (9)
fa6e39c6 02927399 3e Final Frame, Encrypted Content
f683a564 405d68db eeb0656c d57c9eb0 Final Frame, Authentication Tag
+--------+
| Footer |
+--------+
0067 Signature Length (103)
30650230 2a1647ad 98867925 c1712e8f Signature
ade70b3f 2a2bc3b8 50eb91ef 56cfdd18
967d91d8 42d92baf 357bba48 f636c7a0
869cade2 023100aa ae12d08f 8a0afe85
e5054803 110c9ed8 11b2e08a c4a052a9
074217ea 3b01b660 534ac921 bf091d12
3657e2b0 9368bd
```
## Données non encadrées (format de message version 1)
L'exemple suivant illustre le format de message pour des données non encadrées.
**Note**
Dans la mesure du possible, utilisez des données encadrées. Il AWS Encryption SDK prend en charge les données non encadrées uniquement pour une utilisation traditionnelle. Certaines implémentations linguistiques du AWS Encryption SDK peuvent toujours générer du texte chiffré non encadré. Toutes les implémentations linguistiques prises en charge peuvent déchiffrer le texte chiffré encadré et non cadré.
```
+--------+
| Header |
+--------+
01 Version (1.0)
80 Type (128, customer authenticated encrypted data)
0378 Algorithm ID (see Référence relative aux algorithmes du kit)
B8929B01 753D4A45 C0217F39 404F70FF Message ID (random 128-bit value)
008E AAD Length (142)
0004 AAD Key-Value Pair Count (4)
0005 AAD Key-Value Pair 1, Key Length (5)
30746869 73 AAD Key-Value Pair 1, Key ("0This")
0002 AAD Key-Value Pair 1, Value Length (2)
6973 AAD Key-Value Pair 1, Value ("is")
0003 AAD Key-Value Pair 2, Key Length (3)
31616E AAD Key-Value Pair 2, Key ("1an")
000A AAD Key-Value Pair 2, Value Length (10)
656E6372 79774690 6F6E AAD Key-Value Pair 2, Value ("encryption")
0008 AAD Key-Value Pair 3, Key Length (8)
32636F6E 74657874 AAD Key-Value Pair 3, Key ("2context")
0007 AAD Key-Value Pair 3, Value Length (7)
6578616D 706C65 AAD Key-Value Pair 3, Value ("example")
0015 AAD Key-Value Pair 4, Key Length (21)
6177732D 63727970 746F2D70 75626C69 AAD Key-Value Pair 4, Key ("aws-crypto-public-key")
632D6B65 79
0044 AAD Key-Value Pair 4, Value Length (68)
41734738 67473949 6E4C5075 3136594B AAD Key-Value Pair 4, Value ("AsG8gG9InLPu16YKlqXTOD+nykG8YqHAhqecj8aXfD2e5B4gtVE73dZkyClA+rAMOQ==")
6C715854 4F442B6E 796B4738 59714841
68716563 6A386158 66443265 35423467
74564537 33645A6B 79436C41 2B72414D
4F513D3D
0002 Encrypted Data Key Count (2)
0007 Encrypted Data Key 1, Key Provider ID Length (7)
6177732D 6B6D73 Encrypted Data Key 1, Key Provider ID ("aws-kms")
004B Encrypted Data Key 1, Key Provider Information Length (75)
61726E3A 6177733A 6B6D733A 75732D77 Encrypted Data Key 1, Key Provider Information ("arn:aws:kms:us-west-2:111122223333:key/715c0818-5825-4245-a755-138a6d9a11e6")
6573742D 323A3131 31313232 32323333
33333A6B 65792F37 31356330 3831382D
35383235 2D343234 352D6137 35352D31
33386136 64396131 316536
00A7 Encrypted Data Key 1, Encrypted Data Key Length (167)
01010200 7857A1C1 F7370545 4ECA7C83 Encrypted Data Key 1, Encrypted Data Key
956C4702 23DCE8D7 16C59679 973E3CED
02A4EF29 7F000000 7E307C06 092A8648
86F70D01 0706A06F 306D0201 00306806
092A8648 86F70D01 0701301E 06096086
48016503 04012E30 11040C28 4116449A
0F2A0383 659EF802 0110803B B23A8133
3A33605C 48840656 C38BCB1F 9CCE7369
E9A33EBE 33F46461 0591FECA 947262F3
418E1151 21311A75 E575ECC5 61A286E0
3E2DEBD5 CB005D
0007 Encrypted Data Key 2, Key Provider ID Length (7)
6177732D 6B6D73 Encrypted Data Key 2, Key Provider ID ("aws-kms")
004E Encrypted Data Key 2, Key Provider Information Length (78)
61726E3A 6177733A 6B6D733A 63612D63 Encrypted Data Key 2, Key Provider Information ("arn:aws:kms:ca-central-1:111122223333:key/9b13ca4b-afcc-46a8-aa47-be3435b423ff")
656E7472 616C2D31 3A313131 31323232
32333333 333A6B65 792F3962 31336361
34622D61 6663632D 34366138 2D616134
372D6265 33343335 62343233 6666
00A7 Encrypted Data Key 2, Encrypted Data Key Length (167)
01010200 78FAFFFB D6DE06AF AC72F79B Encrypted Data Key 2, Encrypted Data Key
0E57BD87 3F60F4E6 FD196144 5A002C94
AF787150 69000000 7E307C06 092A8648
86F70D01 0706A06F 306D0201 00306806
092A8648 86F70D01 0701301E 06096086
48016503 04012E30 11040CB2 A820D0CC
76616EF2 A6B30D02 0110803B 8073D0F1
FDD01BD9 B0979082 099FDBFC F7B13548
3CC686D7 F3CF7C7A CCC52639 122A1495
71F18A46 80E2C43F A34C0E58 11D05114
2A363C2A E11397
01 Content Type (1, nonframed data)
00000000 Reserved
0C IV Length (12)
00000000 Frame Length (0, nonframed data)
734C1BBE 032F7025 84CDA9D0 IV
2C82BB23 4CBF4AAB 8F5C6002 622E886C Authentication Tag
+------+
| Body |
+------+
D39DD3E5 915E0201 77A4AB11 IV
00000000 0000028E Encrypted Content Length (654)
E8B6F955 B5F22FE4 FD890224 4E1D5155 Encrypted Content
5871BA4C 93F78436 1085E4F8 D61ECE28
59455BD8 D76479DF C28D2E0B BDB3D5D3
E4159DFE C8A944B6 685643FC EA24122B
6766ECD5 E3F54653 DF205D30 0081D2D8
55FCDA5B 9F5318BC F4265B06 2FE7C741
C7D75BCC 10F05EA5 0E2F2F40 47A60344
ECE10AA7 559AF633 9DE2C21B 12AC8087
95FE9C58 C65329D1 377C4CD7 EA103EC1
31E4F48A 9B1CC047 EE5A0719 704211E5
B48A2068 8060DF60 B492A737 21B0DB21
C9B21A10 371E6179 78FAFB0B BAAEC3F4
9D86E334 701E1442 EA5DA288 64485077
54C0C231 AD43571A B9071925 609A4E59
B8178484 7EB73A4F AAE46B26 F5B374B8
12B0000C 8429F504 936B2492 AAF47E94
A5BA804F 7F190927 5D2DF651 B59D4C2F
A15D0551 DAEBA4AF 2060D0D5 CB1DA4E6
5E2034DB 4D19E7CD EEA6CF7E 549C86AC
46B2C979 AB84EE12 202FD6DF E7E3C09F
C2394012 AF20A97E 369BCBDA 62459D3E
C6FFB914 FEFD4DE5 88F5AFE1 98488557
1BABBAE4 BE55325E 4FB7E602 C1C04BEE
F3CB6B86 71666C06 6BF74E1B 0F881F31
B731839B CF711F6A 84CA95F5 958D3B44
E3862DF6 338E02B5 C345CFF8 A31D54F3
6920AA76 0BF8E903 552C5A04 917CCD11
D4E5DF5C 491EE86B 20C33FE1 5D21F0AD
6932E67C C64B3A26 B8988B25 CFA33E2B
63490741 3AB79D60 D8AEFBE9 2F48E25A
978A019C FE49EE0A 0E96BF0D D6074DDB
66DFF333 0E10226F 0A1B219C BE54E4C2
2C15100C 6A2AA3F1 88251874 FDC94F6B
9247EF61 3E7B7E0D 29F3AD89 FA14A29C
76E08E9B 9ADCDF8C C886D4FD A69F6CB4
E24FDE26 3044C856 BF08F051 1ADAD329
C4A46A1E B5AB72FE 096041F1 F3F3571B
2EAFD9CB B9EB8B83 AE05885A 8F2D2793
1E3305D9 0C9E2294 E8AD7E3B 8E4DEC96
6276C5F1 A3B7E51E 422D365D E4C0259C
50715406 822D1682 80B0F2E5 5C94
65B2E942 24BEEA6E A513F918 CCEC1DE3 Authentication Tag
+--------+
| Footer |
+--------+
0067 Signature Length (103)
30650230 7229DDF5 B86A5B64 54E4D627 Signature
CBE194F1 1CC0F8CF D27B7F8B F50658C0
BE84B355 3CED1721 A0BE2A1B 8E3F449E
1BEB8281 023100B2 0CB323EF 58A4ACE3
1559963B 889F72C3 B15D1700 5FB26E61
331F3614 BC407CEE B86A66FA CBF74D9E
34CB7E4B 363A38
```
# Référence de données authentifiées supplémentaires (AAD) du corps pour AWS Encryption SDK
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Vous devez fournir des données authentifiées supplémentaires (données AAD) à l'[algorithme AES GCM](algorithms-reference.md) pour chaque opération de chiffrement. Cela s'applique aux [données du corps](message-format.md#body-structure) encadrées et non encadrées. Pour plus d'informations sur l'AAD et son utilisation en Galois/Counter mode (GCM), voir [Recommandations relatives aux modes de fonctionnement du chiffrement par blocs : Galois/Counter mode (GCM) et GMAC.](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf)
Le tableau suivant décrit les champs formant les données AAD du corps. Les octets sont ajoutés dans l'ordre indiqué.
**Structure des données AAD du corps**
| Champ | Longueur, en octets |
| --- | --- |
| [Message ID](#body-aad-message-id) | 16 |
| [Body AAD Content](#body-aad-content) | Variable. Consultez Contenu AAD du corps dans la liste suivante. |
| [Sequence Number](#body-aad-sequence-number) | 4 |
| [Content Length](#body-aad-content-length) | 8 |
**ID du message**
Même valeur [Message ID](message-format.md#header-message-id) que celle définie dans l'en-tête du message.
**Contenu du corps en AAD**
Valeur codée en UTF-8 déterminée par le type de données du corps utilisé.
Pour les [données non encadrées](message-format.md#body-no-framing), utilisez la valeur `AWSKMSEncryptionClient Single Block`.
Pour les cadres réguliers dans les [données encadrées](message-format.md#body-framing), utilisez la valeur `AWSKMSEncryptionClient Frame`.
Pour le cadre final dans les [données encadrées](message-format.md#body-framing), utilisez la valeur `AWSKMSEncryptionClient Final Frame`.
**Numéro de séquence**
Valeur de 4 octets interprétée comme un entier 32 bits non signé.
Pour les [données encadrées](message-format.md#body-framing), il s'agit du numéro de séquence du cadre.
Pour les [données non encadrées](message-format.md#body-no-framing), utilisez la valeur 1, codée en tant que 4 octets `00 00 00 01` au format hexadécimal.
**Longueur du contenu**
Longueur, en octets, des données en texte brut fournies à l'algorithme pour le chiffrement. Il s'agit d'une valeur de 8 octets interprétée comme un entier 64 bits non signé.
# AWS Encryption SDK référence aux algorithmes
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Si vous créez votre propre bibliothèque capable de lire et d'écrire des textes chiffrés compatibles avec le AWS Encryption SDK, vous devez comprendre comment elle AWS Encryption SDK implémente les suites d'algorithmes prises en charge pour chiffrer les données brutes.
AWS Encryption SDK prend en charge les suites d'algorithmes suivantes. Toutes les suites d'algorithmes AES-GCM possèdent un [vecteur d'initialisation](IV-reference.md) de 12 octets et une balise d'authentification AES-GCM de 16 octets. La suite d'algorithmes par défaut varie en fonction de la AWS Encryption SDK version et de la politique d'engagement clé sélectionnée. Pour plus de détails, voir [Politique d'engagement et suite d'algorithmes](troubleshooting-migration.md#configuration-conflict_1).
**AWS Encryption SDK Suites d'algorithmes**
| ID de l'algorithme | Version du format du message | Algorithme de chiffrement | Longueur de la clé de données (bits) | Algorithme de dérivation de clé | Algorithme de signature | Algorithme d'engagement clé | Longueur des données de la suite d'algorithmes (octets) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 05 78 | 0x02 | AES-GCM | 256 | HKDF avec SHA-512 | ECDSA avec P-384 et SHA-384 | HKDF avec SHA-512 | 32 (engagement clé) |
| 04 78 | 0x02 | AES-GCM | 256 | HKDF avec SHA-512 | Aucune | HKDF avec SHA-512 | 32 (engagement clé) |
| 03 78 | 0x01 | AES-GCM | 256 | HKDF avec SHA-384 | ECDSA avec P-384 et SHA-384 | Aucune | N/A |
| 03 46 | 0x01 | AES-GCM | 192 | HKDF avec SHA-384 | ECDSA avec P-384 et SHA-384 | Aucune | N/A |
| 02 14 | 0x01 | AES-GCM | 128 | HKDF avec SHA-256 | ECDSA avec P-256 et SHA-256 | Aucune | N/A |
| 01 78 | 0x01 | AES-GCM | 256 | HKDF avec SHA-256 | Aucune | Aucune | N/A |
| 01 46 | 0x01 | AES-GCM | 192 | HKDF avec SHA-256 | Aucune | Aucune | N/A |
| 01 14 | 0x01 | AES-GCM | 128 | HKDF avec SHA-256 | Aucune | Aucune | N/A |
| 00 78 | 0x01 | AES-GCM | 256 | Aucune | Aucun | Aucune | N/A |
| 00 46 | 0x01 | AES-GCM | 192 | Aucune | Aucun | Aucune | N/A |
| 00 14 | 0x01 | AES-GCM | 128 | Aucune | Aucun | Aucune | N/A |
**ID de l'algorithme**
Valeur hexadécimale de 2 octets qui identifie de manière unique une implémentation d'algorithme. Cette valeur est enregistrée dans l'[en-tête du message](message-format.md#header-structure) chiffré.
**Version du format du message**
Version du format du message. Les suites d'algorithmes avec engagement clé utilisent le format de message version 2 (0x02). Les suites d'algorithmes sans engagement de clé utilisent le format de message version 1 (0x01).
**Longueur des données de la suite d'algorithmes**
Longueur en octets des données spécifiques à la suite d'algorithmes. Ce champ n'est pris en charge que dans le format de message version 2 (0x02). Dans le format de message version 2 (0x02), ces données apparaissent dans le `Algorithm suite data` champ de l'en-tête du message. Les suites d'algorithmes qui prennent en charge [l'engagement des clés](concepts.md#key-commitment) utilisent 32 octets pour la chaîne d'engagement des clés. Pour plus d'informations, consultez la section **Algorithme d'engagement clé** dans cette liste.
**Longueur de la clé de données**
Longueur de la [clé de données](concepts.md#DEK) en bits. Il AWS Encryption SDK prend en charge les clés 256 bits, 192 bits et 128 bits. La clé de données est générée par un [trousseau de clés](concepts.md#keyring) ou une clé principale.
Dans certaines implémentations, cette clé de données est utilisée comme entrée dans une fonction de dérivation de extract-and-expand clé basée sur HMAC (HKDF). La sortie de la fonction HKDF est utilisée comme la clé de chiffrement des données dans l'algorithme de chiffrement. Pour plus d'informations, voir **Algorithme de dérivation des clés** dans cette liste.
**Algorithme de chiffrement**
Nom et mode de l'algorithme de chiffrement utilisé. Les suites d'algorithmes AWS Encryption SDK utilisent l'algorithme de cryptage Advanced Encryption Standard (AES) avec Galois/Counter mode (GCM).
**Algorithme d'engagement clé**
Algorithme utilisé pour calculer la chaîne d'engagement clé. La sortie est stockée dans le `Algorithm suite data` champ de l'en-tête du message et est utilisée pour valider la clé de données pour l'engagement clé.
Pour une explication technique de l'ajout d'un engagement clé à une suite d'algorithmes, voir [Key Committing AEADs](https://eprint.iacr.org/2020/1153) in Cryptology ePrint Archive.
**Algorithme de dérivation de clé**
La fonction de dérivation de extract-and-expand clé basée sur HMAC (HKDF) utilisée pour dériver la clé de chiffrement des données. AWS Encryption SDK Utilise le HKDF défini dans la [RFC 5869](https://tools.ietf.org/html/rfc5869).
**Suites d'algorithmes sans engagement de clé** (ID d'algorithme `01xx` —`03xx`)
+ La fonction de hachage utilisée est SHA-384 ou SHA-256, selon la suite d'algorithmes.
+ Pour l'étape d'extraction :
+ Aucune valeur salt n'est utilisée. Selon la RFC, le sel est défini sur une chaîne de zéros. La longueur de la chaîne est égale à la longueur de la sortie de la fonction de hachage, qui est de 48 octets pour SHA-384 et de 32 octets pour SHA-256.
+ Le matériel de saisie est la clé de données fournie par le trousseau de clés ou le fournisseur de la clé principale.
+ Pour l'étape de développement :
+ La clé pseudo aléatoire en entrée est la sortie de l'étape d'extraction.
+ Les informations d'entrée sont une concaténation de l'ID de l'algorithme et de l'ID du message (dans cet ordre).
+ La longueur du matériel de saisie de sortie est la **longueur de la clé de données**. Cette sortie est utilisée comme la clé de chiffrement des données dans l'algorithme de chiffrement.
**Suites d'algorithmes avec engagement clé** (identifiant d'algorithme `04xx` et`05xx`)
+ La fonction de hachage utilisée est SHA-512.
+ Pour l'étape d'extraction :
+ Le sel est une valeur aléatoire cryptographique de 256 bits. Dans le [format de message version 2](message-format.md) (0x02), cette valeur est stockée dans le `MessageID` champ.
+ Le matériel de saisie initial est la clé de données fournie par le porte-clés ou le fournisseur de la clé principale.
+ Pour l'étape de développement :
+ La clé pseudo aléatoire en entrée est la sortie de l'étape d'extraction.
+ L'étiquette clé correspond aux octets codés en UTF-8 de la `DERIVEKEY` chaîne dans l'ordre des octets en gros endian.
+ Les informations d'entrée sont une concaténation de l'identifiant de l'algorithme et de l'étiquette clé (dans cet ordre).
+ La longueur du matériel de saisie de sortie est la **longueur de la clé de données**. Cette sortie est utilisée comme la clé de chiffrement des données dans l'algorithme de chiffrement.
**Version du format du message**
Version du format de message utilisé avec la suite d'algorithmes. Pour en savoir plus, consultez [Référence Format des messages du kit](message-format.md).
**Algorithme de signature**
Algorithme de signature utilisé pour générer une [signature numérique](concepts.md#digital-sigs) sur l'en-tête et le corps du texte chiffré. AWS Encryption SDK utilise l'algorithme de signature numérique à courbe elliptique (ECDSA) avec les spécificités suivantes :
+ La courbe elliptique utilisée est soit la courbe P-384, soit la courbe P-256, comme spécifié par l'ID de l'algorithme. Ces courbes sont définies dans le document [Digital Signature Standard (DSS) (FIPS PUB 186-4)](http://doi.org/10.6028/NIST.FIPS.186-4).
+ La fonction de hachage utilisée est la fonction SHA-384 (avec la courbe P-384) ou SHA-256 (avec la courbe P-256).
# AWS Encryption SDK référence du vecteur d'initialisation
| |
| --- |
| Les informations de cette page constituent une référence pour le développement de votre propre bibliothèque de chiffrement compatible avec le kit AWS Encryption SDK. Si vous ne créez pas votre propre bibliothèque de chiffrement compatible, vous n'aurez probablement pas besoin de ces informations. Pour utiliser le AWS Encryption SDK dans l'un des langages de programmation pris en charge, voir[Langages de programmation](programming-languages.md). Pour la spécification qui définit les éléments d'une AWS Encryption SDK implémentation appropriée, voir la [AWS Encryption SDK spécification](https://github.com/awslabs/aws-encryption-sdk-specification/) dans GitHub. |
Le AWS Encryption SDK fournit les [vecteurs d'initialisation](https://en.wikipedia.org/wiki/Initialization_vector) (IVs) requis par toutes les [suites d'algorithmes](algorithms-reference.md) prises en charge. Le kit SDK utilise des numéros de séquence de cadre pour construire un vecteur d'initialisation afin qu'il ne soit pas possible que deux cadres du même message puissent avoir le même vecteur d'initialisation.
Chaque vecteur d'initialisation de 96 bits (12 octets) est construit à partir de deux tableaux d'octets de poids fort concaténés dans l'ordre suivant :
+ 64 bits : 0 (réservé pour une utilisation ultérieure)
+ 32 bits : numéro de séquence du cadre. Pour la balise d'authentification de l'en-tête, cette valeur est uniquement constituée de zéros.
Avant l'introduction de la [mise en cache des clés de données](data-key-caching.md), ils utilisaient AWS Encryption SDK toujours une nouvelle clé de données pour chiffrer chaque message, et le tout IVs était généré de manière aléatoire. Les données générées aléatoirement IVs étaient sûres du point de vue cryptographique, car les clés de données n'étaient jamais réutilisées. Lorsque le SDK a introduit la mise en cache des clés de données, qui réutilise intentionnellement les clés de données, nous avons changé la façon dont le SDK génère. IVs
L'utilisation d'un déterministe IVs qui ne peut pas être répété dans un message augmente considérablement le nombre d'invocations pouvant être exécutées en toute sécurité avec une seule clé de données. En outre, les clés de données qui sont mises en cache utilisent toujours une suite d'algorithmes avec [une fonction de dérivation de clés](https://en.wikipedia.org/wiki/Key_derivation_function). L'utilisation d'un IV déterministe avec une fonction de dérivation de clé pseudo-aléatoire pour dériver des clés de chiffrement à partir d'une clé de données permet de chiffrer 2^32 AWS Encryption SDK messages sans dépasser les limites cryptographiques.
# AWS KMS Détails techniques du porte-clés hiérarchique
Le trousseau de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md) utilise une clé de données unique pour chiffrer chaque message et chiffre chaque clé de données avec une clé d'encapsulation unique dérivée d'une clé de branche active. Il utilise une [dérivation de clé](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1.pdf) en mode compteur avec une fonction pseudo-aléatoire avec HMAC SHA-256 pour dériver la clé d'encapsulation de 32 octets avec les entrées suivantes.
+ Un sel aléatoire de 16 octets
+ La clé de branche active
+ La valeur [codée en UTF-8](https://en.wikipedia.org/wiki/UTF-8) pour l'identifiant du fournisseur de clés « » aws-kms-hierarchy
Le trousseau de clés hiérarchique utilise la clé d'encapsulation dérivée pour chiffrer une copie de la clé de données en texte brut à l'aide du protocole AES-GCM-256 avec une balise d'authentification de 16 octets et les entrées suivantes.
+ La clé d'encapsulation dérivée est utilisée comme clé de chiffrement AES-GCM
+ La clé de données est utilisée comme message AES-GCM
+ Un vecteur d'initialisation aléatoire (IV) de 12 octets est utilisé comme AES-GCM IV
+ Données authentifiées supplémentaires (AAD) contenant les valeurs sérialisées suivantes.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/encryption-sdk/latest/developer-guide/hierarchical-keyring-details.html)