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.
# Chiffrement consultable
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Le chiffrement consultable vous permet de rechercher des enregistrements cryptés sans déchiffrer l'intégralité de la base de données. Cela se fait à l'aide de *balises*, qui créent une carte entre la valeur en texte brut écrite dans un champ et la valeur cryptée réellement stockée dans votre base de données. Le SDK AWS Database Encryption stocke la balise dans un nouveau champ qu'il ajoute à l'enregistrement. Selon le type de balise que vous utilisez, vous pouvez effectuer des recherches de correspondance exacte ou des requêtes complexes plus personnalisées sur vos données chiffrées.
**Note**
[Le chiffrement consultable dans le SDK AWS de chiffrement de base de données est différent du chiffrement symétrique consultable défini dans la recherche universitaire, tel que le chiffrement symétrique consultable.](https://dl.acm.org/doi/10.1145/1180405.1180417)
Une balise est une balise HMAC (Hash Based Message Authentication Code) tronquée qui crée une carte entre le texte brut et les valeurs chiffrées d'un champ. Lorsque vous écrivez une nouvelle valeur dans un champ chiffré configuré pour le chiffrement consultable, le SDK de chiffrement de AWS base de données calcule un HMAC par rapport à la valeur en texte brut. Cette sortie HMAC correspond un à un (1:1) à la valeur en texte brut de ce champ. La sortie HMAC est tronquée afin que plusieurs valeurs de texte clair distinctes correspondent à la même balise HMAC tronquée. Ces faux positifs limitent la capacité d'un utilisateur non autorisé à identifier des informations distinctives concernant la valeur en texte brut. Lorsque vous interrogez une balise, le SDK AWS Database Encryption filtre automatiquement ces faux positifs et renvoie le résultat en texte brut de votre requête.
Le nombre moyen de faux positifs générés pour chaque balise est déterminé par la longueur restante de la balise après troncature. Pour obtenir de l'aide pour déterminer la longueur de balise appropriée pour votre implémentation, consultez la section [Détermination de la longueur de balise](choosing-beacon-length.md).
**Note**
Le chiffrement consultable est conçu pour être mis en œuvre dans de nouvelles bases de données non peuplées. Toute balise configurée dans une base de données existante ne cartographiera que les nouveaux enregistrements téléchargés dans la base de données, il n'y a aucun moyen pour une balise de mapper des données existantes.
**Rubriques**
+ [Les balises sont-elles adaptées à mon ensemble de données ?](#are-beacons-right-for-me)
+ [Scénario de chiffrement consultable](#beacon-overview-example)
## Les balises sont-elles adaptées à mon ensemble de données ?
L'utilisation de balises pour effectuer des requêtes sur des données chiffrées réduit les coûts de performance associés aux bases de données chiffrées côté client. Lorsque vous utilisez des balises, il existe un compromis inhérent entre l'efficacité de vos requêtes et la quantité d'informations révélées sur la distribution de vos données. La balise ne modifie pas l'état chiffré du champ. Lorsque vous chiffrez et signez un champ avec le SDK de chiffrement AWS de base de données, la valeur en texte brut du champ n'est jamais exposée à la base de données. La base de données stocke la valeur chiffrée aléatoire du champ.
Les balises sont stockées à côté des champs cryptés à partir desquels elles sont calculées. Cela signifie que même si un utilisateur non autorisé ne peut pas voir les valeurs en texte clair d'un champ crypté, il peut être en mesure d'effectuer une analyse statistique sur les balises pour en savoir plus sur la distribution de votre ensemble de données et, dans les cas extrêmes, identifier les valeurs en texte clair auxquelles une balise correspond. La façon dont vous configurez vos balises peut atténuer ces risques. En particulier, [le choix de la bonne longueur de balise](choosing-beacon-length.md) peut vous aider à préserver la confidentialité de votre ensemble de données.
**Sécurité et performance**
+ Plus la longueur de la balise est courte, plus la sécurité est préservée.
+ Plus la longueur de la balise est longue, plus les performances sont préservées.
Le chiffrement consultable peut ne pas être en mesure de fournir les niveaux de performance et de sécurité souhaités pour tous les ensembles de données. Passez en revue votre modèle de menace, vos exigences de sécurité et vos besoins en matière de performances avant de configurer des balises.
Tenez compte des exigences d'unicité des ensembles de données suivantes pour déterminer si le chiffrement consultable convient à votre ensemble de données.
**Diffusion**
Le niveau de sécurité préservé par une balise dépend de la distribution de votre ensemble de données. Lorsque vous configurez un champ chiffré pour le chiffrement consultable, le SDK de chiffrement AWS de base de données calcule un HMAC sur la base des valeurs en texte brut écrites dans ce champ. Toutes les balises calculées pour un champ donné sont calculées à l'aide de la même clé, à l'exception des bases de données mutualisées qui utilisent une clé distincte pour chaque locataire. Cela signifie que si la même valeur en texte brut est écrite plusieurs fois dans le champ, la même balise HMAC est créée pour chaque instance de cette valeur en texte clair.
Vous devez éviter de créer des balises à partir de champs contenant des valeurs très communes. Prenons l'exemple d'une base de données qui enregistre l'adresse de chaque résident de l'État de l'Illinois. Si vous créez une balise à partir du `City` champ crypté, la balise calculée sur « Chicago » sera surreprésentée en raison du pourcentage élevé de la population de l'Illinois qui vit à Chicago. Même si un utilisateur non autorisé peut uniquement lire les valeurs cryptées et les valeurs des balises, il peut être en mesure d'identifier les enregistrements contenant des données relatives aux résidents de Chicago si la balise préserve cette distribution. Pour minimiser la quantité d'informations distinctives révélées concernant votre distribution, vous devez suffisamment tronquer votre balise. La longueur de balise requise pour masquer cette distribution inégale entraîne des coûts de performance importants qui risquent de ne pas répondre aux besoins de votre application.
Vous devez analyser soigneusement la distribution de votre jeu de données afin de déterminer dans quelle mesure vos balises doivent être tronquées. La longueur de balise restante après la troncature est directement corrélée à la quantité d'informations statistiques pouvant être identifiées sur votre distribution. Vous devrez peut-être choisir des longueurs de balise plus courtes pour minimiser suffisamment la quantité d'informations distinctives révélées à propos de votre ensemble de données.
Dans les cas extrêmes, vous ne pouvez pas calculer la longueur d'une balise pour un jeu de données distribué de manière inégale afin d'équilibrer efficacement les performances et la sécurité. Par exemple, vous ne devez pas créer de balise à partir d'un champ qui contient le résultat d'un test médical pour une maladie rare. Étant donné que les `NEGATIVE` résultats devraient être nettement plus répandus dans l'ensemble de données, les `POSITIVE` résultats peuvent être facilement identifiés en fonction de leur rareté. Il est très difficile de masquer la distribution lorsque le champ ne comporte que deux valeurs possibles. Si vous utilisez une balise suffisamment courte pour masquer la distribution, toutes les valeurs en texte brut correspondent à la même balise HMAC. Si vous utilisez une longueur de balise plus longue, il est évident de savoir quelles balises correspondent à des valeurs en texte brut`POSITIVE`.
**Corrélation**
Nous vous recommandons vivement d'éviter de créer des balises distinctes à partir de champs contenant des valeurs corrélées. Les balises construites à partir de champs corrélés nécessitent des longueurs de balise plus courtes pour minimiser suffisamment la quantité d'informations révélées sur la distribution de chaque ensemble de données à un utilisateur non autorisé. Vous devez analyser soigneusement votre ensemble de données, notamment son entropie et la distribution conjointe des valeurs corrélées, afin de déterminer dans quelle mesure vos balises doivent être tronquées. Si la longueur des balises qui en résulte ne répond pas à vos besoins en termes de performances, les balises ne conviennent peut-être pas à votre ensemble de données.
Par exemple, vous ne devez pas créer deux balises `City` et deux `ZIPCode` champs distincts, car le code postal sera probablement associé à une seule ville. Généralement, les faux positifs générés par une balise limitent la capacité d'un utilisateur non autorisé à identifier des informations distinctives concernant votre ensemble de données. Mais la corrélation entre les `ZIPCode` champs `City` et signifie qu'un utilisateur non autorisé peut facilement identifier les résultats faussement positifs et distinguer les différents codes postaux.
Vous devez également éviter de créer des balises à partir de champs contenant les mêmes valeurs en texte brut. Par exemple, vous ne devez pas créer de balise à partir de `preferredPhone` champs `mobilePhone` et de champs, car ils contiennent probablement les mêmes valeurs. Si vous créez des balises distinctes à partir des deux champs, le SDK AWS de chiffrement de base de données crée les balises pour chaque champ sous des clés différentes. Il en résulte deux balises HMAC différentes pour la même valeur en texte brut. Il est peu probable que les deux balises distinctes présentent les mêmes faux positifs et un utilisateur non autorisé pourrait être en mesure de distinguer différents numéros de téléphone.
Même si votre jeu de données contient des champs corrélés ou présente une distribution inégale, vous pouvez peut-être créer des balises qui préservent la confidentialité de votre ensemble de données en utilisant des longueurs de balise plus courtes. Cependant, la longueur des balises ne garantit pas que chaque valeur unique de votre ensemble de données produira un certain nombre de faux positifs qui minimiseront efficacement la quantité d'informations distinctives révélées à propos de votre ensemble de données. La longueur de la balise estime uniquement le nombre moyen de faux positifs produits. Plus votre jeu de données est inégalement distribué, moins la longueur de balise est efficace pour déterminer le nombre moyen de faux positifs produits.
Examinez attentivement la distribution des champs à partir desquels vous construisez les balises et déterminez dans quelle mesure vous devrez tronquer la longueur des balises pour répondre à vos exigences de sécurité. Les rubriques suivantes de ce chapitre supposent que vos balises sont distribuées de manière uniforme et ne contiennent pas de données corrélées.
## Scénario de chiffrement consultable
L'exemple suivant illustre une solution de chiffrement consultable simple. En application, les champs d'exemple utilisés dans cet exemple peuvent ne pas respecter les recommandations d'unicité de distribution et de corrélation pour les balises. Vous pouvez utiliser cet exemple comme référence lorsque vous découvrirez les concepts de chiffrement consultables dans ce chapitre.
Prenons l'exemple d'une base de données nommée `Employees` qui suit les données des employés d'une entreprise. *Chaque enregistrement de la base de données contient des champs appelés *EmployeeID *LastName**, *FirstName*, et Address.* Chaque champ de la `Employees` base de données est identifié par la clé primaire`EmployeeID`.
Voici un exemple d'enregistrement en texte brut dans la base de données.
```
{
"EmployeeID": 101,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
```
Si vous avez marqué les `FirstName` champs `LastName` et comme `ENCRYPT_AND_SIGN` dans vos [actions cryptographiques, les](concepts.md#crypt-actions) valeurs de ces champs sont chiffrées localement avant d'être téléchargées dans la base de données. Les données cryptées téléchargées sont entièrement aléatoires, la base de données ne reconnaît pas ces données comme étant protégées. Il détecte simplement les entrées de données typiques. Cela signifie que l'enregistrement réellement stocké dans la base de données peut ressembler à ce qui suit.
```
{
"PersonID": 101,
"LastName": "1d76e94a2063578637d51371b363c9682bad926cbd",
"FirstName": "21d6d54b0aaabc411e9f9b34b6d53aa4ef3b0a35",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
```
Si vous devez interroger la base de données pour obtenir des correspondances exactes dans le `LastName` champ, [configurez une balise standard](configure-beacons.md#config-standard-beacons) nommée *LastName*pour mapper les valeurs en texte clair écrites dans le `LastName` champ aux valeurs cryptées stockées dans la base de données.
Cette balise effectue des calculs HMACs à partir des valeurs en texte brut du `LastName` champ. Chaque sortie HMAC est tronquée de sorte qu'elle ne correspond plus exactement à la valeur en texte brut. Par exemple, le hachage complet et le hachage tronqué pour `Jones` peuvent ressembler à ce qui suit.
**Hachage complet**
`2aa4e9b404c68182562b6ec761fcca5306de527826a69468885e59dc36d0c3f824bdd44cab45526f70a2a18322000264f5451acf75f9f817e2b35099d408c833`
**Hachage tronqué**
`b35099d408c833`
Une fois la balise standard configurée, vous pouvez effectuer des recherches d'égalité sur le `LastName` terrain. Par exemple, si vous souhaitez effectuer une recherche`Jones`, utilisez la *LastName*balise pour effectuer la requête suivante.
```
LastName = Jones
```
Le SDK AWS Database Encryption filtre automatiquement les faux positifs et renvoie le résultat en texte brut de votre requête.
# Balises
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Une balise est une balise HMAC (Hash Based Message Authentication Code) tronquée qui crée une carte entre la valeur en texte brut écrite dans un champ et la valeur cryptée réellement stockée dans votre base de données. La balise ne modifie pas l'état chiffré du champ. La balise calcule un HMAC sur la valeur en texte brut du champ et le stocke à côté de la valeur cryptée. Cette sortie HMAC correspond un à un (1:1) à la valeur en texte brut de ce champ. La sortie HMAC est tronquée afin que plusieurs valeurs de texte clair distinctes correspondent à la même balise HMAC tronquée. Ces faux positifs limitent la capacité d'un utilisateur non autorisé à identifier des informations distinctives concernant la valeur en texte brut.
Les balises ne peuvent être créées qu'à partir de champs marqués ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` dans `ENCRYPT_AND_SIGN` le `SIGN_ONLY` cadre de vos actions [cryptographiques](concepts.md#crypt-actions). La balise elle-même n'est ni signée ni cryptée. Vous ne pouvez pas créer une balise avec des champs marqués`DO_NOTHING`.
Le type de balise que vous configurez détermine le type de requêtes que vous pouvez effectuer. Il existe deux types de balises compatibles avec le chiffrement consultable. *Les balises standard effectuent des* recherches d'égalité. *Les balises composées combinent des* chaînes de texte en clair littérales et des balises standard pour effectuer des opérations de base de données complexes. Après avoir [configuré vos balises](configure-beacons.md), vous devez configurer un index secondaire pour chaque balise avant de pouvoir effectuer une recherche dans les champs chiffrés. Pour de plus amples informations, veuillez consulter [Configuration des index secondaires avec des balises](ddb-searchable-encryption.md#ddb-beacon-indexes).
**Topics**
+ [Balises standard](#standard-beacon-overview)
+ [Balises composées](#compound-beacon-overview)
## Balises standard
Les balises standard constituent le moyen le plus simple d'implémenter un chiffrement consultable dans votre base de données. Ils ne peuvent effectuer des recherches d'égalité que pour un seul champ crypté ou virtuel. Pour savoir comment configurer les balises standard, consultez la section [Configuration des balises standard](configure-beacons.md#config-standard-beacons).
Le champ à partir duquel une balise standard est construite est appelé *source de balise*. Il identifie l'emplacement des données que la balise doit cartographier. La source de la balise peut être un champ crypté ou un *champ virtuel*. La source de balise de chaque balise standard doit être unique. Vous ne pouvez pas configurer deux balises avec la même source de balise.
Les balises standard peuvent être utilisées pour effectuer des recherches d'égalité pour un champ crypté ou virtuel. Ils peuvent également être utilisés pour créer des balises composées afin d'effectuer des opérations de base de données plus complexes. Pour vous aider à organiser et à gérer les balises standard, le SDK AWS de chiffrement de base de données fournit les *styles de balises facultatifs suivants qui définissent l'utilisation prévue d'une balise* standard. Pour plus d'informations, voir [Définition des styles de balises](configure-beacons.md#define-beacon-styles).
Vous pouvez créer une balise standard qui effectue des recherches d'égalité pour un seul champ crypté, ou vous pouvez créer une balise standard qui effectue des recherches d'égalité sur la concaténation de plusieurs `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champs `ENCRYPT_AND_SIGN``SIGN_ONLY`, et en créant un champ virtuel.
**Champs virtuels**
Un champ virtuel est un champ conceptuel construit à partir d'un ou de plusieurs champs sources. La création d'un champ virtuel n'entraîne pas l'inscription d'un nouveau champ dans votre enregistrement. Le champ virtuel n'est pas explicitement stocké dans votre base de données. Il est utilisé dans une configuration de balise standard pour donner à la balise des instructions sur la façon d'identifier un segment spécifique d'un champ ou de concaténer plusieurs champs dans un enregistrement pour effectuer une requête spécifique. Un champ virtuel nécessite au moins un champ crypté.
L'exemple suivant montre les types de transformations et de requêtes que vous pouvez effectuer avec un champ virtuel. En application, les champs d'exemple utilisés dans cet exemple peuvent ne pas respecter les recommandations d'unicité de [distribution](searchable-encryption.md#searchable-encryption-distribution) et de [corrélation](searchable-encryption.md#searchable-encryption-correlated-values) pour les balises.
Par exemple, si vous souhaitez effectuer des recherches d'égalité sur la concaténation de `LastName` champs `FirstName` et, vous pouvez créer l'un des champs virtuels suivants.
+ Un `NameTag` champ virtuel, construit à partir de la première lettre du `FirstName` champ, suivie du `LastName` champ, le tout en minuscules. Ce champ virtuel vous permet d'effectuer des requêtes`NameTag=mjones`.
+ Un `LastFirst` champ virtuel, qui est construit à partir du `LastName` champ, suivi du `FirstName` champ. Ce champ virtuel vous permet d'effectuer des requêtes`LastFirst=JonesMary`.
Ou, si vous souhaitez effectuer des recherches d'égalité sur un segment spécifique d'un champ chiffré, créez un champ virtuel qui identifie le segment que vous souhaitez interroger.
Par exemple, si vous souhaitez interroger un `IPAddress` champ chiffré à l'aide des trois premiers segments de l'adresse IP, créez le champ virtuel suivant.
+ Un `IPSegment` champ virtuel, construit à partir de`Segments(‘.’, 0, 3)`. Ce champ virtuel vous permet d'effectuer des requêtes`IPSegment=192.0.2`. La requête renvoie tous les enregistrements dont `IPAddress` la valeur commence par « 192.0.2 ».
Les champs virtuels doivent être uniques. Il est impossible de créer deux champs virtuels à partir des mêmes champs sources.
Pour obtenir de l'aide sur la configuration des champs virtuels et des balises qui les utilisent, consultez la section [Création d'un champ virtuel](configure-beacons.md#create-virtual-field).
## Balises composées
Les balises composées créent des index qui améliorent les performances des requêtes et vous permettent d'effectuer des opérations de base de données plus complexes. Vous pouvez utiliser des balises composées pour combiner des chaînes de texte brut littérales et des balises standard pour effectuer des requêtes complexes sur des enregistrements chiffrés, telles que l'interrogation de deux types d'enregistrements différents à partir d'un seul index ou l'interrogation d'une combinaison de champs à l'aide d'une clé de tri. Pour d'autres exemples de solutions de balises composées, voir [Choisir un type de balise](choosing-beacon-type.md).
Les balises composées peuvent être construites à partir de balises standard ou d'une combinaison de balises standard et de champs signés. Ils sont construits à partir d'une liste de pièces. Toutes les balises composées doivent inclure une liste de [parties cryptées](configure-beacons.md#encrypted-parts) identifiant les `ENCRYPT_AND_SIGN` champs inclus dans la balise. Chaque `ENCRYPT_AND_SIGN` champ doit être identifié par une balise standard. Les balises composées plus complexes peuvent également inclure une liste de [parties signées](configure-beacons.md#signed-parts) identifiant le texte en clair `SIGN_ONLY` ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` les champs inclus dans la balise, et une liste de [pièces de constructeur](configure-beacons.md#constructor-parts) identifiant toutes les manières possibles dont la balise composée peut assembler les champs.
**Note**
Le SDK AWS Database Encryption prend également en charge les *balises signées* qui peuvent être entièrement configurées à partir de texte brut `SIGN_ONLY` et de champs. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Les balises signées sont un type de balise composée qui indexe et exécute des requêtes complexes sur des champs signés, mais non chiffrés. Pour de plus amples informations, veuillez consulter [Création de balises signées](configure.md#signed-beacons).
Pour obtenir de l'aide sur la configuration des balises composées, consultez [la section Configuration des balises composées](configure-beacons.md#config-compound-beacons).
La façon dont vous configurez votre balise composée détermine les types de requêtes qu'elle peut effectuer. Par exemple, vous pouvez rendre certaines parties cryptées et signées facultatives pour permettre une plus grande flexibilité dans vos requêtes. Pour plus d'informations sur les types de requêtes que les balises composées peuvent effectuer, consultez[Interrogation de balises](using-beacons.md#querying-beacons).
# Balises de planification
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Les balises sont conçues pour être mises en œuvre dans de nouvelles bases de données non peuplées. Toute balise configurée dans une base de données existante ne mappera que les nouveaux enregistrements écrits dans la base de données. Les balises sont calculées à partir de la valeur en texte brut d'un champ. Une fois le champ crypté, il n'est plus possible pour la balise de mapper les données existantes. Une fois que vous avez écrit de nouveaux enregistrements avec une balise, vous ne pouvez pas mettre à jour la configuration de la balise. Cependant, vous pouvez ajouter de nouvelles balises pour les nouveaux champs que vous ajoutez à votre enregistrement.
Pour implémenter le chiffrement consultable, vous devez utiliser le trousseau de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md) pour générer, chiffrer et déchiffrer les clés de données utilisées pour protéger vos enregistrements. Pour de plus amples informations, veuillez consulter [Utilisation du trousseau de clés hiérarchique pour un chiffrement consultable](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
Avant de configurer les [balises](searchable-encryption.md#beacon-definition) pour le chiffrement consultable, vous devez passer en revue vos exigences en matière de chiffrement, vos modèles d'accès à la base de données et votre modèle de menace afin de déterminer la meilleure solution pour votre base de données.
Le [type de balise](beacons.md) que vous configurez détermine le type de requêtes que vous pouvez effectuer. La [longueur de balise](choosing-beacon-length.md) que vous spécifiez dans la configuration de balise standard détermine le nombre attendu de faux positifs produits pour une balise donnée. Nous vous recommandons vivement d'identifier et de planifier les types de requêtes que vous devez effectuer avant de configurer vos balises. Une fois que vous avez utilisé une balise, la configuration ne peut pas être mise à jour.
Nous vous recommandons vivement de passer en revue et d'effectuer les tâches suivantes avant de configurer des balises.
+ [Déterminez si les balises sont adaptées à votre ensemble de données](searchable-encryption.md#are-beacons-right-for-me)
+ [Choisissez un type de balise](choosing-beacon-type.md)
+ [Choisissez une longueur de balise](choosing-beacon-length.md)
+ [Choisissez un nom de balise](choosing-beacon-name.md)
N'oubliez pas les exigences d'unicité des balises suivantes lorsque vous planifiez la solution de chiffrement consultable pour votre base de données.
+ **Chaque balise standard doit avoir une [source de balise](beacons.md#beacon-source) unique**
Il est impossible de créer plusieurs balises standard à partir du même champ crypté ou virtuel.
Cependant, une seule balise standard peut être utilisée pour construire plusieurs balises composées.
+ **Évitez de créer un champ virtuel dont les champs source se chevauchent avec les balises standard existantes**
La construction d'une balise standard à partir d'un champ virtuel contenant un champ source utilisé pour créer une autre balise standard peut réduire la sécurité des deux balises.
Pour de plus amples informations, veuillez consulter [Considérations relatives à la sécurité des champs virtuels](configure-beacons.md#virtual-field-considerations).
## Considérations relatives aux bases de données mutualisées
Pour interroger les balises configurées dans une base de données mutualisée, vous devez inclure le champ qui stocke le fichier `branch-key-id` associé au locataire qui a chiffré l'enregistrement dans votre requête. Vous définissez ce champ lorsque vous [définissez la source de la clé de balise](use-hierarchical-keyring.md#beacon-key-source). Pour que la requête aboutisse, la valeur de ce champ doit identifier les éléments clés de balise appropriés requis pour recalculer la balise.
Avant de configurer vos balises, vous devez décider de la manière dont vous comptez les inclure `branch-key-id` dans vos requêtes. Pour plus d'informations sur les différentes manières dont vous pouvez inclure le `branch-key-id` dans vos requêtes, consultez[Interrogation de balises dans une base de données mutualisée](searchable-encryption-multitenant.md#query-multitenant-beacons).
# Choisir un type de balise
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
*Grâce au chiffrement consultable, vous pouvez rechercher des enregistrements chiffrés en mappant les valeurs en texte brut dans un champ crypté à l'aide d'une balise.* Le type de balise que vous configurez détermine le type de requêtes que vous pouvez effectuer.
Nous vous recommandons vivement d'identifier et de planifier les types de requêtes que vous devez effectuer avant de configurer vos balises. Après avoir [configuré vos balises](configure-beacons.md), vous devez configurer un index secondaire pour chaque balise avant de pouvoir effectuer une recherche dans les champs chiffrés. Pour de plus amples informations, veuillez consulter [Configuration des index secondaires avec des balises](ddb-searchable-encryption.md#ddb-beacon-indexes).
Les balises créent une carte entre la valeur en texte brut écrite dans un champ et la valeur cryptée réellement stockée dans votre base de données. Vous ne pouvez pas comparer les valeurs de deux balises standard, même si elles contiennent le même texte brut sous-jacent. Les deux balises standard produiront deux balises HMAC différentes pour les mêmes valeurs en texte brut. Par conséquent, les balises standard ne peuvent pas effectuer les requêtes suivantes.
+ `beacon1 = beacon2`
+ `beacon1 IN (beacon2)`
+ `value IN (beacon1, beacon2, ...)`
+ `CONTAINS(beacon1, beacon2)`
Vous ne pouvez effectuer les requêtes ci-dessus que si vous comparez les [parties signées](configure-beacons.md#signed-parts) des balises composées, à l'exception de l'`CONTAINS`opérateur, que vous pouvez utiliser avec les balises composées pour identifier la valeur complète d'un champ chiffré ou signé que contient la balise assemblée. Lorsque vous comparez des parties signées, vous pouvez éventuellement inclure le préfixe d'une [partie chiffrée](configure-beacons.md#encrypted-parts), mais vous ne pouvez pas inclure la valeur cryptée d'un champ. Pour plus d'informations sur les types de requêtes que les balises standard et composées peuvent effectuer, consultez la section [Interrogation](using-beacons.md#querying-beacons) de balises.
Envisagez les solutions de chiffrement consultables suivantes lorsque vous examinez les modèles d'accès à votre base de données. Les exemples suivants définissent la balise à configurer pour répondre aux différentes exigences de chiffrement et d'interrogation.
## Balises standard
[Les balises standard](beacons.md#standard-beacon-overview) peuvent uniquement effectuer des recherches d'égalité. Vous pouvez utiliser des balises standard pour effectuer les requêtes suivantes.
### Interrogez un seul champ chiffré
Si vous souhaitez identifier les enregistrements contenant une valeur spécifique pour un champ chiffré, créez une balise standard.
#### Exemples
Dans l'exemple suivant, considérez une base de données nommée `UnitInspection` qui suit les données d'inspection d'une installation de production. Chaque enregistrement de la base de données contient des champs appelés `work_id``inspection_date`,`inspector_id_last4`, et`unit`. L'identifiant complet de l'inspecteur est un nombre compris entre 0 et 99 999 999. Toutefois, pour garantir une distribution uniforme de l'ensemble de données, `inspector_id_last4` seuls les quatre derniers chiffres de l'identifiant de l'inspecteur sont enregistrés. Chaque champ de la base de données est identifié par la clé primaire`work_id`. Les `unit` champs `inspector_id_last4` et sont marqués `ENCRYPT_AND_SIGN` dans les [actions cryptographiques](concepts.md#crypt-actions).
Voici un exemple d'entrée en texte brut dans la `UnitInspection` base de données.
```
{
"work_id": "1c7fcff3-6e74-41a8-b7f7-925dc039830b",
"inspection_date": 2023-06-07,
"inspector_id_last4": 8744,
"unit": 229304973450
}
```
**Interroger un seul champ chiffré dans un enregistrement**
Si le `inspector_id_last4` champ doit être chiffré, mais que vous devez tout de même l'interroger pour obtenir des correspondances exactes, créez une balise standard à partir du `inspector_id_last4` champ. Utilisez ensuite la balise standard pour créer un index secondaire. Vous pouvez utiliser cet index secondaire pour effectuer une requête sur le `inspector_id_last4` champ crypté.
Pour obtenir de l'aide sur la configuration des balises standard, consultez [la section Configuration des balises standard](configure-beacons.md#config-standard-beacons).
### Interroger un champ virtuel
Un [champ virtuel](beacons.md#virtual-field) est un champ conceptuel construit à partir d'un ou de plusieurs champs sources. Si vous souhaitez effectuer des recherches d'égalité pour un segment spécifique d'un champ crypté, ou effectuer des recherches d'égalité sur la concaténation de plusieurs champs, créez une balise standard à partir d'un champ virtuel. Tous les champs virtuels doivent inclure au moins un champ source chiffré.
#### Exemples
Les exemples suivants créent des champs virtuels pour la `Employees` base de données. Voici un exemple d'enregistrement en texte brut dans la `Employees` base de données.
```
{
"EmployeeID": 101,
"SSN": 000-00-0000,
"LastName": "Jones",
"FirstName": "Mary",
"Address": {
"Street": "123 Main",
"City": "Anytown",
"State": "OH",
"ZIPCode": 12345
}
}
```
**Interroger un segment d'un champ chiffré**
Dans cet exemple, le `SSN` champ est crypté.
Si vous souhaitez interroger le `SSN` champ à l'aide des quatre derniers chiffres d'un numéro de sécurité sociale, créez un champ virtuel qui identifie le segment que vous souhaitez interroger.
Un `Last4SSN` champ virtuel, construit à partir de, vous `Suffix(4)` permet d'effectuer des requêtes`Last4SSN=0000`. Utilisez ce champ virtuel pour créer une balise standard. Utilisez ensuite la balise standard pour créer un index secondaire. Vous pouvez utiliser cet index secondaire pour effectuer des requêtes sur le champ virtuel. Cette requête renvoie tous les enregistrements dont `SSN` la valeur se termine par les quatre derniers chiffres que vous avez spécifiés.
**Interrogez la concaténation de plusieurs champs**
L'exemple suivant montre les types de transformations et de requêtes que vous pouvez effectuer avec un champ virtuel. En application, les champs d'exemple utilisés dans cet exemple peuvent ne pas respecter les recommandations d'unicité de [distribution](searchable-encryption.md#searchable-encryption-distribution) et de [corrélation](searchable-encryption.md#searchable-encryption-correlated-values) pour les balises.
Si vous souhaitez effectuer des recherches d'égalité sur une concaténation de `LastName` champs `FirstName` et, vous pouvez créer un `NameTag` champ virtuel, construit à partir de la première lettre du `FirstName` champ, suivie du champ, le `LastName` tout en minuscules. Utilisez ce champ virtuel pour créer une balise standard. Utilisez ensuite la balise standard pour créer un index secondaire. Vous pouvez utiliser cet index secondaire pour effectuer des requêtes `NameTag=mjones` sur le champ virtuel.
Au moins un des champs source doit être chiffré. L'`FirstName`un ou l'autre `LastName` pourrait être chiffré, ou les deux pourraient être chiffrés. Tous les champs source en texte brut doivent être marqués en tant que `SIGN_ONLY` ou `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` dans vos actions [cryptographiques](concepts.md#crypt-actions).
Pour obtenir de l'aide sur la configuration des champs virtuels et des balises qui les utilisent, consultez la section [Création d'un champ virtuel](configure-beacons.md#create-virtual-field).
## Balises composées
[Les balises composées](beacons.md#compound-beacon-overview) créent un index à partir de chaînes de texte brut littérales et de balises standard pour effectuer des opérations de base de données complexes. Vous pouvez utiliser des balises composées pour effectuer les requêtes suivantes.
### Interrogez une combinaison de champs chiffrés sur un seul index
Si vous devez interroger une combinaison de champs chiffrés sur un seul index, créez une balise composée qui combine les balises standard individuelles construites pour chaque champ chiffré afin de former un index unique.
Après avoir configuré la balise composée, vous pouvez créer un index secondaire qui spécifie la balise composée comme clé de partition pour effectuer des requêtes de correspondance exacte ou avec une clé de tri pour effectuer des requêtes plus complexes. Les index secondaires qui spécifient la balise composée comme clé de tri peuvent effectuer des requêtes de correspondance exacte et des requêtes complexes plus personnalisées.
#### Exemples
Pour les exemples suivants, considérez une base de données nommée `UnitInspection` qui suit les données d'inspection d'une installation de production. Chaque enregistrement de la base de données contient des champs appelés `work_id``inspection_date`,`inspector_id_last4`, et`unit`. L'identifiant complet de l'inspecteur est un nombre compris entre 0 et 99 999 999. Toutefois, pour garantir une distribution uniforme de l'ensemble de données, `inspector_id_last4` seuls les quatre derniers chiffres de l'identifiant de l'inspecteur sont enregistrés. Chaque champ de la base de données est identifié par la clé primaire`work_id`. Les `unit` champs `inspector_id_last4` et sont marqués `ENCRYPT_AND_SIGN` dans les [actions cryptographiques](concepts.md#crypt-actions).
Voici un exemple d'entrée en texte brut dans la `UnitInspection` base de données.
```
{
"work_id": "1c7fcff3-6e74-41a8-b7f7-925dc039830b",
"inspection_date": 2023-06-07,
"inspector_id_last4": 8744,
"unit": 229304973450
}
```
**Effectuez des recherches d'égalité sur une combinaison de champs cryptés**
Si vous souhaitez interroger la `UnitInspection` base de données pour obtenir des correspondances exactes`inspector_id_last4.unit`, créez d'abord des balises standard distinctes pour les `unit` champs `inspector_id_last4` et. Créez ensuite une balise composée à partir des deux balises standard.
Après avoir configuré la balise composée, créez un index secondaire qui spécifie la balise composée comme clé de partition. Utilisez cet index secondaire pour rechercher des correspondances exactes sur`inspector_id_last4.unit`. Par exemple, vous pouvez interroger cette balise pour trouver une liste des inspections effectuées par un inspecteur pour une unité donnée.
**Réaliser des requêtes complexes sur une combinaison de champs chiffrés**
Si vous souhaitez interroger la `UnitInspection` base de données sur `inspector_id_last4` et`inspector_id_last4.unit`, créez d'abord des balises standard distinctes pour les `unit` champs `inspector_id_last4` et. Créez ensuite une balise composée à partir des deux balises standard.
Après avoir configuré la balise composée, créez un index secondaire qui spécifie la balise composée comme clé de tri. Utilisez cet index secondaire pour rechercher dans la `UnitInspection` base de données les entrées commençant par un certain inspecteur ou pour demander à la base de données une liste de toutes les unités appartenant à une plage d'identifiants d'unités spécifique qui ont été inspectées par un certain inspecteur. Vous pouvez également effectuer des recherches de correspondance exacte sur`inspector_id_last4.unit`.
Pour obtenir de l'aide sur la configuration des balises composées, consultez [la section Configuration des balises composées](configure-beacons.md#config-compound-beacons).
### Interrogez une combinaison de champs chiffrés et de champs en texte brut sur un seul index
Si vous devez interroger une combinaison de champs chiffrés et de champs en texte brut sur un seul index, créez une balise composée qui combine des balises standard individuelles et des champs de texte en clair pour former un index unique. Les champs de texte brut utilisés pour créer la balise composée doivent être marqués `SIGN_ONLY` ou figurer `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` dans vos actions [cryptographiques](concepts.md#crypt-actions).
Après avoir configuré la balise composée, vous pouvez créer un index secondaire qui spécifie la balise composée comme clé de partition pour effectuer des requêtes de correspondance exacte ou avec une clé de tri pour effectuer des requêtes plus complexes. Les index secondaires qui spécifient la balise composée comme clé de tri peuvent effectuer des requêtes de correspondance exacte et des requêtes complexes plus personnalisées.
#### Exemples
Pour les exemples suivants, considérez une base de données nommée `UnitInspection` qui suit les données d'inspection d'une installation de production. Chaque enregistrement de la base de données contient des champs appelés `work_id``inspection_date`,`inspector_id_last4`, et`unit`. L'identifiant complet de l'inspecteur est un nombre compris entre 0 et 99 999 999. Toutefois, pour garantir une distribution uniforme de l'ensemble de données, `inspector_id_last4` seuls les quatre derniers chiffres de l'identifiant de l'inspecteur sont enregistrés. Chaque champ de la base de données est identifié par la clé primaire`work_id`. Les `unit` champs `inspector_id_last4` et sont marqués `ENCRYPT_AND_SIGN` dans les [actions cryptographiques](concepts.md#crypt-actions).
Voici un exemple d'entrée en texte brut dans la `UnitInspection` base de données.
```
{
"work_id": "1c7fcff3-6e74-41a8-b7f7-925dc039830b",
"inspection_date": 2023-06-07,
"inspector_id_last4": 8744,
"unit": 229304973450
}
```
**Effectuez des recherches d'égalité sur une combinaison de champs**
Si vous souhaitez interroger la `UnitInspection` base de données pour les inspections effectuées par un inspecteur spécifique à une date précise, créez d'abord une balise standard pour le `inspector_id_last4` champ. Le `inspector_id_last4` champ est marqué `ENCRYPT_AND_SIGN` dans les [actions cryptographiques](concepts.md#crypt-actions). Toutes les parties cryptées nécessitent leur propre balise standard. Le `inspection_date` champ est marqué `SIGN_ONLY` et ne nécessite pas de balise standard. Créez ensuite une balise composée à partir du `inspection_date` champ et de la balise `inspector_id_last4` standard.
Après avoir configuré la balise composée, créez un index secondaire qui spécifie la balise composée comme clé de partition. Utilisez cet index secondaire pour rechercher dans les bases de données des enregistrements correspondant exactement à un inspecteur et à une date d'inspection spécifiques. Par exemple, vous pouvez interroger la base de données pour obtenir la liste de toutes les inspections effectuées à une date précise par l'inspecteur dont l'identifiant se termine `8744` par un identifiant.
**Exécuter des requêtes complexes sur une combinaison de champs**
Si vous souhaitez interroger la base de données pour les inspections effectuées dans une `inspection_date` plage, ou interroger la base de données pour les inspections effectuées sur une `inspection_date` contrainte particulière par `inspector_id_last4` ou`inspector_id_last4.unit`, créez d'abord des balises standard distinctes pour les champs `inspector_id_last4` et`unit`. Créez ensuite une balise composée à partir du `inspection_date` champ de texte brut et des deux balises standard.
Après avoir configuré la balise composée, créez un index secondaire qui spécifie la balise composée comme clé de tri. Utilisez cet index secondaire pour effectuer des requêtes pour les inspections effectuées à des dates spécifiques par un inspecteur spécifique. Par exemple, vous pouvez interroger la base de données pour obtenir la liste de toutes les unités inspectées à la même date. Vous pouvez également interroger la base de données pour obtenir une liste de toutes les inspections effectuées sur une unité spécifique entre une plage de dates d'inspection donnée.
Pour obtenir de l'aide sur la configuration des balises composées, consultez [la section Configuration des balises composées](configure-beacons.md#config-compound-beacons).
# Choix de la longueur d'une balise
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Lorsque vous écrivez une nouvelle valeur dans un champ chiffré configuré pour le chiffrement consultable, le SDK de chiffrement de AWS base de données calcule un HMAC par rapport à la valeur en texte brut. Cette sortie HMAC correspond un à un (1:1) à la valeur en texte brut de ce champ. La sortie HMAC est tronquée afin que plusieurs valeurs de texte clair distinctes correspondent à la même balise HMAC tronquée. Ces collisions, ou *faux positifs*, limitent la capacité d'un utilisateur non autorisé à identifier des informations distinctives concernant la valeur en texte brut.
Le nombre moyen de faux positifs générés pour chaque balise est déterminé par la longueur restante de la balise après troncature. Vous devez uniquement définir la longueur des balises lors de la configuration des balises standard. Les balises composées utilisent les longueurs des balises standard à partir desquelles elles sont construites.
La balise ne modifie pas l'état chiffré du champ. Cependant, lorsque vous utilisez des balises, il existe un compromis inhérent entre l'efficacité de vos requêtes et la quantité d'informations révélées sur la distribution de vos données.
L'objectif du chiffrement consultable est de réduire les coûts de performance associés aux bases de données chiffrées côté client en utilisant des balises pour effectuer des requêtes sur des données chiffrées. Les balises sont stockées à côté des champs cryptés à partir desquels elles sont calculées. Cela signifie qu'ils peuvent révéler des informations distinctives sur la distribution de votre ensemble de données. Dans des cas extrêmes, un utilisateur non autorisé peut être en mesure d'analyser les informations révélées sur votre distribution et de les utiliser pour identifier la valeur en texte brut d'un champ. Le choix de la bonne longueur de balise peut contribuer à atténuer ces risques et à préserver la confidentialité de votre distribution.
Passez en revue votre modèle de menace pour déterminer le niveau de sécurité dont vous avez besoin. Par exemple, plus il y a de personnes qui ont accès à votre base de données, mais ne devraient pas avoir accès aux données en texte brut, plus vous souhaiterez peut-être protéger la confidentialité de la distribution de votre ensemble de données. Pour accroître la confidentialité, une balise doit générer davantage de faux positifs. L'augmentation de la confidentialité entraîne une réduction des performances des requêtes.
**Sécurité et performance**
+ Une balise **trop longue produit trop** peu de faux positifs et peut révéler des informations distinctives sur la distribution de votre ensemble de données.
+ Une balise **trop courte produit trop** de faux positifs et augmente le coût des performances des requêtes car elle nécessite une analyse plus approfondie de la base de données.
Lorsque vous déterminez la longueur de balise appropriée pour votre solution, vous devez trouver une longueur qui préserve de manière adéquate la sécurité de vos données sans affecter les performances de vos requêtes plus que ce qui est absolument nécessaire. Le niveau de sécurité préservé par une balise dépend de la [distribution](searchable-encryption.md#searchable-encryption-distribution) de votre ensemble de données et de la [corrélation](searchable-encryption.md#searchable-encryption-correlated-values) des champs à partir desquels vos balises sont construites. Les rubriques suivantes supposent que vos balises sont distribuées de manière uniforme et ne contiennent pas de données corrélées.
**Topics**
+ [Calcul de la longueur des balises](#calculate-beacon-length)
+ [Exemple](#beacon-length-example)
## Calcul de la longueur des balises
La longueur de la balise est définie en *bits* et fait référence au nombre de bits de la balise HMAC conservés après la troncature. La longueur de balise recommandée varie en fonction de la distribution du jeu de données, de la présence de valeurs corrélées et de vos exigences spécifiques en matière de sécurité et de performances. Si votre jeu de données est distribué de manière uniforme, vous pouvez utiliser les équations et procédures suivantes pour identifier la meilleure longueur de balise pour votre implémentation. Ces équations ne font qu'estimer le nombre moyen de faux positifs produits par la balise. Elles ne garantissent pas que chaque valeur unique de votre jeu de données produira un nombre spécifique de faux positifs.
**Note**
L'efficacité de ces équations dépend de la distribution de votre jeu de données. Si votre jeu de données n'est pas distribué de manière uniforme, consultez[Les balises sont-elles adaptées à mon ensemble de données ?](searchable-encryption.md#are-beacons-right-for-me).
En général, plus votre jeu de données est éloigné d'une distribution uniforme, plus vous devez raccourcir la longueur de votre balise.
1.
**Estimer la population**
La population est le nombre attendu de valeurs uniques dans le champ à partir duquel votre balise standard est construite, il ne s'agit pas du nombre total attendu de valeurs stockées dans le champ. Prenons l'exemple d'un `Room` champ crypté qui identifie le lieu des réunions des employés. Le `Room` champ devrait stocker 100 000 valeurs au total, mais les employés ne peuvent réserver que 50 salles différentes pour les réunions. Cela signifie que la population est de 50 car seules 50 valeurs uniques peuvent être stockées `Room` sur le terrain.
**Note**
Si votre balise standard est construite à partir d'un [champ virtuel](beacons.md#virtual-field), la population utilisée pour calculer la longueur de la balise est le nombre de combinaisons uniques créées par le champ virtuel.
Lorsque vous estimez votre population, veillez à tenir compte de la croissance prévue de l'ensemble de données. Une fois que vous avez écrit de nouveaux enregistrements avec la balise, vous ne pouvez pas mettre à jour la longueur de la balise. Passez en revue votre modèle de menace et toutes les solutions de base de données existantes afin de créer une estimation du nombre de valeurs uniques que vous prévoyez de stocker dans ce champ au cours des cinq prochaines années.
Votre population n'a pas besoin d'être précise. Identifiez d'abord le nombre de valeurs uniques dans votre base de données actuelle ou estimez le nombre de valeurs uniques que vous comptez stocker au cours de la première année. Posez ensuite les questions suivantes pour déterminer la croissance prévue des valeurs uniques au cours des cinq prochaines années.
+ Vous attendez-vous à ce que les valeurs uniques soient multipliées par 10 ?
+ Vous attendez-vous à ce que les valeurs uniques soient multipliées par 100 ?
+ Vous attendez-vous à ce que les valeurs uniques soient multipliées par 1000 ?
La différence entre 50 000 et 60 000 valeurs uniques n'est pas significative et elles aboutiront toutes deux à la même longueur de balise recommandée. Cependant, la différence entre 50 000 et 500 000 valeurs uniques aura un impact significatif sur la longueur de balise recommandée.
Envisagez d'examiner les données publiques sur la fréquence des types de données courants, tels que les codes postaux ou les noms de famille. Par exemple, il existe 41 707 codes postaux aux États-Unis d'Amérique. La population que vous utilisez doit être proportionnelle à votre propre base de données. Si le `ZIPCode` champ de votre base de données inclut des données provenant de l'ensemble des États-Unis d'Amérique, vous pouvez définir votre population comme étant 41 707, même si `ZIPCode` le champ ne contient *pas* actuellement 41 707 valeurs uniques. Si le `ZIPCode` champ de votre base de données inclut uniquement les données d'un seul État, et n'inclura que les données d'un seul État, vous pouvez définir votre population comme le nombre total de codes postaux dans cet État au lieu de 41 704.
1. **Calculez la plage recommandée pour le nombre de collisions attendu**
Pour déterminer la longueur de balise appropriée pour un champ donné, vous devez d'abord identifier une plage appropriée pour le nombre de collisions attendu. Le nombre de collisions attendu représente le nombre moyen attendu de valeurs de texte brut uniques correspondant à une balise HMAC particulière. Le nombre attendu de faux positifs pour une valeur unique en texte brut est inférieur d'un au nombre de collisions attendu.
Nous recommandons que le nombre de collisions attendu soit supérieur ou égal à deux, et inférieur à la racine carrée de votre population. Les équations suivantes ne fonctionnent que si votre population possède 16 valeurs uniques ou plus.
```
2 ≤ number of collisions < √(Population)
```
Si le nombre de collisions est inférieur à deux, la balise produira trop peu de faux positifs. Nous recommandons deux comme nombre minimum de collisions attendues, car cela signifie qu'en moyenne, chaque valeur unique du champ générera au moins un faux positif en étant mappée à une autre valeur unique.
1. **Calculez la plage recommandée pour les longueurs de balise**
Après avoir identifié le nombre minimum et maximum de collisions attendues, utilisez l'équation suivante pour identifier une plage de longueurs de balise appropriées.
```
number of collisions = Population * 2-(beacon length)
```
Tout d'abord, **déterminez la longueur de la balise** lorsque le nombre de collisions attendues est égal à deux (le nombre minimum recommandé de collisions attendues).
```
2 = Population * 2-(beacon length)
```
Ensuite, déterminez la **longueur de la balise** pour laquelle le nombre de collisions attendu est égal à la racine carrée de votre population (le nombre maximum recommandé de collisions attendues).
```
√(Population) = Population * 2-(beacon length)
```
Nous recommandons d'arrondir le résultat produit par cette équation à la longueur de balise la plus courte. Par exemple, si l'équation produit une longueur de balise de 15,6, nous recommandons d'arrondir cette valeur à 15 bits au lieu d'arrondir à 16 bits.
1. **Choisissez une longueur de balise**
Ces équations identifient uniquement une plage recommandée de longueurs de balise pour votre champ. Nous vous recommandons d'utiliser une balise plus courte pour préserver la sécurité de votre ensemble de données dans la mesure du possible. Cependant, la longueur de la balise que vous utilisez réellement est déterminée par votre modèle de menace. Tenez compte de vos exigences en matière de performances lorsque vous examinez votre modèle de menace afin de déterminer la longueur de balise la mieux adaptée à votre champ.
L'utilisation d'une longueur de balise plus courte réduit les performances des requêtes, tandis que l'utilisation d'une longueur de balise plus longue réduit la sécurité. En général, si votre jeu de données est inégalement [distribué](searchable-encryption.md#searchable-encryption-distribution) ou si vous créez des balises distinctes à partir de champs [corrélés](searchable-encryption.md#searchable-encryption-correlated-values), vous devez utiliser des balises de plus courte longueur afin de minimiser la quantité d'informations révélées sur la distribution de vos ensembles de données.
Si vous examinez votre modèle de menace et que vous déterminez que les informations distinctives révélées concernant la distribution d'un champ ne constituent pas une menace pour votre sécurité globale, vous pouvez choisir d'utiliser une longueur de balise supérieure à la plage recommandée que vous avez calculée. Par exemple, si vous avez calculé la plage de longueurs de balise recommandée pour un champ entre 9 et 16 bits, vous pouvez choisir d'utiliser une longueur de balise de 24 bits pour éviter toute perte de performance.
Choisissez soigneusement la longueur de votre balise. Une fois que vous avez écrit de nouveaux enregistrements avec la balise, vous ne pouvez pas mettre à jour la longueur de la balise.
## Exemple
Prenons l'exemple d'une base de données qui a marqué le `unit` champ comme `ENCRYPT_AND_SIGN` dans les [actions cryptographiques](concepts.md#crypt-actions). Pour configurer une balise standard pour le `unit` champ, nous devons déterminer le nombre attendu de faux positifs et la longueur de la balise pour le `unit` champ.
1. Estimer la population
Après avoir examiné notre modèle de menace et notre solution de base de données actuelle, nous nous attendons à ce que le `unit` champ contienne à terme 100 000 valeurs uniques.
Cela signifie que **la population est égale à 100 000 habitants**.
1. Calculez la plage recommandée pour le nombre de collisions attendu.
Dans cet exemple, le nombre de collisions attendu doit être compris entre 2 et 316.
```
2 ≤ number of collisions < √(Population)
```
1.
```
2 ≤ number of collisions < √(100,000)
```
1.
```
2 ≤ number of collisions < 316
```
1. Calculez la plage recommandée pour la longueur de balise.
Dans cet exemple, la longueur de la balise doit être comprise entre 9 et 16 bits.
```
number of collisions = Population * 2-(beacon length)
```
1. Calculez la longueur de la balise lorsque le nombre de collisions attendu est égal au minimum identifié à **l'étape 2**.
```
2 = 100,000 * 2-(beacon length)
```
Longueur de la balise = 15,6, soit 15 bits
1. Calculez la longueur de la balise lorsque le nombre de collisions attendu est égal au maximum identifié à **l'étape 2**.
```
316 = 100,000 * 2-(beacon length)
```
Longueur de la balise = 8,3, soit 8 bits
1. Déterminez la longueur de balise adaptée à vos exigences de sécurité et de performance.
Pour chaque bit inférieur à 15, le coût de performance et la sécurité doublent.
+ 16 bits
+ En moyenne, chaque valeur unique correspond à 1,5 autre unité.
+ Sécurité : deux enregistrements portant la même balise HMAC tronquée ont 66 % de chances d'avoir la même valeur en texte brut.
+ Performance : une requête permet de récupérer 15 enregistrements pour 10 enregistrements que vous avez réellement demandés.
+ 14 bits
+ En moyenne, chaque valeur unique correspond à 6,1 autres unités.
+ Sécurité : deux enregistrements portant la même balise HMAC tronquée ont 33 % de chances d'avoir la même valeur en texte brut.
+ Performance : une requête permet de récupérer 30 enregistrements pour 10 enregistrements que vous avez réellement demandés.
# Choisir un nom de balise
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Chaque balise est identifiée par un *nom de balise* unique. Une fois qu'une balise est configurée, le nom de la balise est le nom que vous utilisez lorsque vous interrogez un champ chiffré. Le nom d'une balise peut être le même que celui d'un champ crypté ou d'un [champ virtuel](beacons.md#virtual-field), mais il ne peut pas être le même que celui d'un champ non chiffré. Deux balises différentes ne peuvent pas porter le même nom de balise.
Pour des exemples illustrant comment nommer et configurer les balises, consultez la section [Configuration des balises](configure-beacons.md).
**Nommer une balise standard**
Lorsque vous nommez des balises standard, nous recommandons vivement que le nom de votre balise corresponde à la [*source de la balise*](beacons.md#beacon-source) dans la mesure du possible. Cela signifie que le nom de la balise et le nom du champ crypté ou [virtuel](beacons.md#virtual-field) à partir duquel votre balise standard est construite sont identiques. Par exemple, si vous créez une balise standard pour un champ chiffré nommé`LastName`, le nom de votre balise doit également être`LastName`.
Lorsque le nom de votre balise est identique à celui de la source de la balise, vous pouvez omettre la source de la balise dans votre configuration et le SDK de chiffrement de AWS base de données utilisera automatiquement le nom de la balise comme source de balise.
# Configuration des balises
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Il existe deux types de balises qui prennent en charge le chiffrement consultable. Les balises standard effectuent des recherches d'égalité. Ils constituent le moyen le plus simple d'implémenter le chiffrement consultable dans votre base de données. Les balises composées combinent des chaînes de texte en clair littérales et des balises standard pour effectuer des requêtes plus complexes.
Les balises sont conçues pour être mises en œuvre dans de nouvelles bases de données non peuplées. Toute balise configurée dans une base de données existante ne mappera que les nouveaux enregistrements écrits dans la base de données. Les balises sont calculées à partir de la valeur en texte brut d'un champ. Une fois le champ crypté, il n'est plus possible pour la balise de mapper les données existantes. Une fois que vous avez écrit de nouveaux enregistrements avec une balise, vous ne pouvez pas mettre à jour la configuration de la balise. Cependant, vous pouvez ajouter de nouvelles balises pour les nouveaux champs que vous ajoutez à votre enregistrement.
Après avoir déterminé vos modèles d'accès, la configuration des balises doit être la deuxième étape de l'implémentation de votre base de données. Ensuite, après avoir configuré toutes vos balises, vous devez créer un jeu de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md), définir la version de la balise, [configurer un index secondaire pour chaque balise](ddb-searchable-encryption.md#ddb-beacon-indexes), définir vos [actions cryptographiques](concepts.md#crypt-actions) et configurer votre base de données et le client du SDK AWS Database Encryption. Pour plus d'informations, consultez la section [Utilisation de balises](using-beacons.md).
Pour faciliter la définition de la version des balises, nous vous recommandons de créer des listes pour les balises standard et composées. Ajoutez chaque balise que vous créez à la liste de balises standard ou composée correspondante au fur et à mesure de sa configuration.
**Topics**
+ [Configuration des balises standard](#config-standard-beacons)
+ [Configuration de balises composées](#config-compound-beacons)
+ [Exemples de configuration](beacon-config-examples.md)
## Configuration des balises standard
Les [balises standard](beacons.md#standard-beacon-overview) constituent le moyen le plus simple d'implémenter un chiffrement consultable dans votre base de données. Ils ne peuvent effectuer des recherches d'égalité que pour un seul champ crypté ou virtuel.
### Exemple de syntaxe de configuration
------
#### [ Java ]
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
------
#### [ C\$1 / .NET ]
```
var standardBeaconList = new List();
StandardBeacon exampleStandardBeacon = new StandardBeacon
{
Name = "beaconName",
Length = 10
};
standardBeaconList.Add(exampleStandardBeacon);
```
------
#### [ Rust ]
```
let standard_beacon_list = vec à partir duquel votre balise standard est construite dans la mesure du possible. Deux balises différentes ne peuvent pas porter le même nom de balise. Pour obtenir de l'aide pour déterminer le meilleur nom de balise pour votre implémentation, consultez [Choisir un nom de balise](choosing-beacon-name.md).
**Longueur de la balise**
Nombre de bits de la valeur de hachage de la balise conservés après la troncature.
La longueur de la balise détermine le nombre moyen de faux positifs produits par une balise donnée. Pour plus d'informations et pour vous aider à déterminer la longueur de balise appropriée pour votre implémentation, consultez la section [Détermination de la longueur de balise](choosing-beacon-length.md).
**Source de balise (facultatif)**
Champ à partir duquel une balise standard est construite.
La source de la balise doit être un nom de champ ou un index faisant référence à la valeur d'un champ imbriqué. Lorsque le nom de votre balise est identique à celui de la source de la balise, vous pouvez omettre la source de la balise dans votre configuration et le SDK de chiffrement de AWS base de données utilisera automatiquement le nom de la balise comme source de balise.
### Création d'un champ virtuel
Pour créer un [champ virtuel](beacons.md#virtual-field), vous devez fournir un nom pour le champ virtuel et une liste des champs sources. L'ordre dans lequel vous ajoutez les champs source à la liste des pièces virtuelles détermine l'ordre dans lequel ils sont concaténés pour créer le champ virtuel. L'exemple suivant concatène deux champs source dans leur intégralité pour créer un champ virtuel.
**Note**
Nous vous recommandons de vérifier que vos champs virtuels produisent le résultat attendu avant de remplir votre base de données. Pour plus d'informations, consultez la section [Tester les sorties des balises](ddb-searchable-encryption.md#ddb-beacon-testing).
------
#### [ Java ]
**Voir l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/VirtualBeaconSearchableEncryptionExample.java)
```
List virtualPartList = new ArrayList<>();
virtualPartList.add(sourceField1);
virtualPartList.add(sourceField2);
VirtualField virtualFieldName = VirtualField.builder()
.name("virtualFieldName")
.parts(virtualPartList)
.build();
List virtualFieldList = new ArrayList<>();
virtualFieldList.add(virtualFieldName);
```
------
#### [ C\$1 / .NET ]
**Voir l'exemple de code complet** : [VirtualBeaconSearchableEncryptionExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/VirtualBeaconSearchableEncryptionExample.cs)
```
var virtualPartList = new List { sourceField1, sourceField2 };
var virtualFieldName = new VirtualField
{
Name = "virtualFieldName",
Parts = virtualPartList
};
var virtualFieldList = new List { virtualFieldName };
```
------
#### [ Rust ]
**Voir l'exemple de code complet** : [virtual\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/virtual_beacon_searchable_encryption.rs)
```
let virtual_part_list = vec![source_field_one, source_field_two];
let state_and_has_test_result_field = VirtualField::builder()
.name("virtual_field_name")
.parts(virtual_part_list)
.build()?;
let virtual_field_list = vec![virtual_field_name];
```
------
Pour créer un champ virtuel avec un segment spécifique d'un champ source, vous devez définir cette transformation avant d'ajouter le champ source à votre liste de pièces virtuelles.
#### Considérations relatives à la sécurité des champs virtuels
Les balises ne modifient pas l'état chiffré du champ. Cependant, lorsque vous utilisez des balises, il existe un compromis inhérent entre l'efficacité de vos requêtes et la quantité d'informations révélées sur la distribution de vos données. La façon dont vous configurez votre balise détermine le niveau de sécurité préservé par cette balise.
Évitez de créer un champ virtuel dont les champs source se chevauchent avec les balises standard existantes. La création de champs virtuels incluant un champ source qui a déjà été utilisé pour créer une balise standard peut réduire le niveau de sécurité des deux balises. L'ampleur de la réduction de la sécurité dépend du niveau d'entropie ajouté par les champs source supplémentaires. Le niveau d'entropie est déterminé par la distribution de valeurs uniques dans le champ source supplémentaire et par le nombre de bits que le champ source supplémentaire contribue à la taille globale du champ virtuel.
Vous pouvez utiliser la population et la [longueur des balises](choosing-beacon-length.md) pour déterminer si les champs source d'un champ virtuel préservent la sécurité de votre ensemble de données. La population est le nombre attendu de valeurs uniques dans un champ. Votre population n'a pas besoin d'être précise. Pour obtenir de l'aide pour estimer la population d'un champ, voir [Estimer la population](choosing-beacon-length.md#estimate-population).
Examinez l'exemple suivant lorsque vous examinez la sécurité de vos champs virtuels.
+ Beacon1 est construit à partir de. `FieldA` `FieldA`a une population supérieure à **2 (longueur de Beacon1**).
+ Beacon2 est construit à partir de`VirtualField`, qui est construit à partir de`FieldA`, `FieldB``FieldC`, et. `FieldD` Ensemble, `FieldB``FieldC`, et `FieldD` ont une population supérieure à **2 N**
Beacon2 préserve la sécurité de Beacon1 et de Beacon2 si les affirmations suivantes sont vraies :
```
N ≥ (Beacon1 length)/2
```
and
```
N ≥ (Beacon2 length)/2
```
### Définition des styles de balises
Les balises standard peuvent être utilisées pour effectuer des recherches d'égalité pour un champ crypté ou virtuel. Ils peuvent également être utilisés pour créer des balises composées afin d'effectuer des opérations de base de données plus complexes. Pour vous aider à organiser et à gérer les balises standard, le SDK AWS de chiffrement de base de données fournit les *styles de balises facultatifs suivants qui définissent l'utilisation prévue d'une balise* standard.
**Note**
Pour définir les styles de balises, vous devez utiliser la version 3.2 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant d'ajouter des styles de balises à vos configurations de balises.
------
#### [ PartOnly ]
Une balise standard définie comme ne `PartOnly` peut être utilisée que pour définir une [partie cryptée](#encrypted-parts) d'une balise composée. Vous ne pouvez pas interroger directement une balise `PartOnly` standard.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.partOnly(PartOnly.builder().build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1//.NET**
```
new StandardBeacon
{
Name = "beaconName",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
PartOnly = new PartOnly()
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon_name")
.length(beacon_length_in_bits)
.style(BeaconStyle::PartOnly(PartOnly::builder().build()?))
.build()?
```
------
#### [ Shared ]
Par défaut, chaque balise standard génère une clé HMAC unique pour le calcul de la balise. Par conséquent, vous ne pouvez pas effectuer de recherche d'égalité sur les champs chiffrés à partir de deux balises standard distinctes. Une balise standard définie comme `Shared` utilise la clé HMAC d'une autre balise standard pour ses calculs.
Par exemple, si vous devez comparer des `beacon1` champs à des `beacon2` champs, `beacon2` définissez-les comme une `Shared` balise qui utilise la clé HMAC de `beacon1` pour ses calculs.
**Note**
Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `Shared` balises. `Shared`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler quels champs partagés contiennent la même valeur en texte brut.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beacon2")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.shared(Shared.builder().other("beacon1").build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1//.NET**
```
new StandardBeacon
{
Name = "beacon2",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
Shared = new Shared { Other = "beacon1" }
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon2")
.length(beacon_length_in_bits)
.style(BeaconStyle::Shared(
Shared::builder().other("beacon1").build()?,
))
.build()?
```
------
#### [ AsSet ]
Par défaut, si la valeur d'un champ est un ensemble, le SDK AWS de chiffrement de base de données calcule une balise standard unique pour l'ensemble. Par conséquent, vous ne pouvez pas exécuter la requête `CONTAINS(a, :value)` où se `a` trouve un champ crypté. Une balise standard définie comme `AsSet` calcule des valeurs de balise standard individuelles pour chaque élément individuel de l'ensemble et stocke la valeur de balise dans l'élément sous forme d'ensemble. Cela permet au SDK AWS de chiffrement de base de données d'exécuter la requête`CONTAINS(a, :value)`.
Pour définir une balise `AsSet` standard, les éléments de l'ensemble doivent appartenir à la même population afin qu'ils puissent tous utiliser la même [longueur de balise](choosing-beacon-length.md). L'ensemble de balises peut comporter moins d'éléments que le jeu de texte en clair en cas de collisions lors du calcul des valeurs des balises.
**Note**
Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `AsSet` balises. `AsSet`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler la taille de l'ensemble de texte en clair.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beaconName")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.asSet(AsSet.builder().build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1//.NET**
```
new StandardBeacon
{
Name = "beaconName",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
AsSet = new AsSet()
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon_name")
.length(beacon_length_in_bits)
.style(BeaconStyle::AsSet(AsSet::builder().build()?))
.build()?
```
------
#### [ SharedSet ]
Une balise standard définie comme `SharedSet` combine les `AsSet` fonctions `Shared` et afin que vous puissiez effectuer des recherches d'égalité sur les valeurs cryptées d'un ensemble et d'un champ. Cela permet au SDK AWS de chiffrement de base de données d'exécuter la requête `CONTAINS(a, b)` lorsqu'il `a` s'agit d'un ensemble chiffré et `b` d'un champ chiffré.
**Note**
Tenez compte de vos besoins en matière de sécurité et de performances avant de configurer des `Shared` balises. `SharedSet`les balises peuvent augmenter la quantité d'informations statistiques pouvant être identifiées sur la distribution de votre ensemble de données. Par exemple, ils peuvent révéler la taille de l'ensemble de texte en clair ou les champs partagés contenant la même valeur en texte brut.
**Java**
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("beacon2")
.length(beaconLengthInBits)
.style(
BeaconStyle.builder()
.sharedSet(SharedSet.builder().other("beacon1").build())
.build()
)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
**C\$1//.NET**
```
new StandardBeacon
{
Name = "beacon2",
Length = beaconLengthInBits,
Style = new BeaconStyle
{
SharedSet = new SharedSet { Other = "beacon1" }
}
}
```
**Rust**
```
StandardBeacon::builder()
.name("beacon2")
.length(beacon_length_in_bits)
.style(BeaconStyle::SharedSet(
SharedSet::builder().other("beacon1").build()?,
))
.build()?
```
------
## Configuration de balises composées
Les balises composées combinent des chaînes de texte brut littérales et des balises standard pour effectuer des opérations de base de données complexes, telles que l'interrogation de deux types d'enregistrement différents à partir d'un seul index ou l'interrogation d'une combinaison de champs à l'aide d'une clé de tri. Les balises composées peuvent être construites à partir de `ENCRYPT_AND_SIGN``SIGN_ONLY`, et de `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champs. Vous devez créer une balise standard pour chaque champ chiffré inclus dans la balise composée.
**Note**
Nous vous recommandons de vérifier que vos balises composées produisent le résultat attendu avant de remplir votre base de données. Pour plus d'informations, consultez la section [Tester les sorties des balises](ddb-searchable-encryption.md#ddb-beacon-testing).
### Exemple de syntaxe de configuration
------
#### [ Java ]
**Configuration de balise composée**
L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées.
```
List compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
.name("compoundBeaconName")
.split(".")
.encrypted(encryptedPartList)
.signed(signedPartList)
.constructors(constructorList)
.build();
compoundBeaconList.add(exampleCompoundBeacon);
```
**Définition de la version de la balise**
L'exemple suivant définit les listes de pièces chiffrées et signées de manière globale dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section [Utilisation des balises](using-beacons.md).
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.encryptedParts(encryptedPartList)
.signedParts(signedPartList)
.version(1) // MUST be 1
.keyStore(keyStore)
.keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branchKeyId)
.cacheTTL(6000)
.build())
.build())
.build()
);
```
------
#### [ C\$1 / .NET ]
**Voir l'exemple de code complet** : [BeaconConfig.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/complexexample/BeaconConfig.cs)
**Configuration de balise composée**
L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées.
```
var compoundBeaconList = new List();
var exampleCompoundBeacon = new CompoundBeacon
{
Name = "compoundBeaconName",
Split = ".",
Encrypted = encryptedPartList,
Signed = signedPartList,
Constructors = constructorList
};
compoundBeaconList.Add(exampleCompoundBeacon);
```
**Définition de la version de la balise**
L'exemple suivant définit les listes de pièces chiffrées et signées de manière globale dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section [Utilisation des balises](using-beacons.md).
```
var beaconVersions = new List
{
new BeaconVersion
{
StandardBeacons = standardBeaconList,
CompoundBeacons = compoundBeaconList,
EncryptedParts = encryptedPartsList,
SignedParts = signedPartsList,
Version = 1, // MUST be 1
KeyStore = keyStore,
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branchKeyId,
CacheTTL = 6000
}
}
}
};
```
------
#### [ Rust ]
**Voir l'exemple de code complet** : [beacon\$1config.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/complexexample/beacon_config.rs)
**Configuration de balise composée**
L'exemple suivant définit des listes de pièces chiffrées et signées localement dans la configuration des balises composées.
```
let compound_beacon_list = vec.
```
let beacon_versions = BeaconVersion::builder()
.standard_beacons(standard_beacon_list)
.compound_beacons(compound_beacon_list)
.encrypted_parts(encrypted_parts_list)
.signed_parts(signed_parts_list)
.version(1) // MUST be 1
.key_store(key_store.clone())
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
.key_id(branch_key_id)
.cache_ttl(6000)
.build()?,
))
.build()?;
let beacon_versions = vec![beacon_versions];
```
------
Vous pouvez définir vos [parties chiffrées](#encrypted-parts) et vos [parties signées](#signed-parts) dans des listes définies localement ou globalement. Nous vous recommandons de définir vos parties cryptées et signées dans une liste globale dans la [version balise](using-beacons.md#beacon-version) dans la mesure du possible. En définissant les parties chiffrées et signées de manière globale, vous pouvez définir chaque partie une seule fois, puis les réutiliser dans plusieurs configurations de balises composées. Si vous n'avez l'intention d'utiliser une pièce chiffrée ou signée qu'une seule fois, vous pouvez la définir dans une liste locale dans la configuration des balises composées. Vous pouvez référencer des pièces locales et globales dans votre [liste de constructeurs](#constructor-parts).
Si vous définissez vos listes de pièces chiffrées et signées de manière globale, vous devez fournir une liste de composants du constructeur identifiant toutes les manières possibles dont la balise composée peut assembler les champs dans votre configuration de balise composée.
**Note**
Pour définir des listes de pièces chiffrées et signées de manière globale, vous devez utiliser la version 3.2 ou ultérieure du SDK AWS Database Encryption. Déployez la nouvelle version sur tous les lecteurs avant de définir de nouvelles pièces de manière globale.
Vous ne pouvez pas mettre à jour les configurations de balises existantes pour définir des listes de pièces chiffrées et signées dans le monde entier.
Pour configurer une balise composée, fournissez les valeurs suivantes.
**Nom de la balise**
Le nom que vous utilisez lorsque vous interrogez un champ chiffré.
Le nom d'une balise peut être le même que celui d'un champ crypté ou d'un champ virtuel, mais il ne peut pas être le même que celui d'un champ non chiffré. Deux balises ne peuvent pas porter le même nom de balise. Pour obtenir de l'aide pour déterminer le meilleur nom de balise pour votre implémentation, consultez [Choisir un nom de balise](choosing-beacon-name.md).
**Caractère divisé**
Le caractère utilisé pour séparer les parties qui composent votre balise composée.
Le caractère divisé ne peut apparaître dans les valeurs en texte brut d'aucun des champs à partir desquels la balise composée est construite.
**Liste de pièces cryptée**
Identifie les `ENCRYPT_AND_SIGN` champs inclus dans la balise composée.
Chaque partie doit inclure un nom et un préfixe. Le nom de pièce doit être le nom de la balise standard construite à partir du champ crypté. Le préfixe peut être n'importe quelle chaîne, mais il doit être unique. Une pièce chiffrée ne peut pas avoir le même préfixe qu'une pièce signée. Nous recommandons d'utiliser une valeur courte qui distingue la pièce des autres parties desservies par la balise composée.
Nous vous recommandons de définir vos parties cryptées de manière globale dans la mesure du possible. Vous pouvez envisager de définir une partie chiffrée localement si vous avez l'intention de ne l'utiliser que dans une seule balise composée. Une partie cryptée définie localement ne peut pas avoir le même préfixe ou le même nom qu'une partie cryptée définie globalement.
```
List encryptedPartList = new ArrayList<>();
EncryptedPart encryptedPartExample = EncryptedPart.builder()
.name("standardBeaconName")
.prefix("E-")
.build();
encryptedPartList.add(encryptedPartExample);
```
```
var encryptedPartList = new List();
var encryptedPartExample = new EncryptedPart
{
Name = "compoundBeaconName",
Prefix = "E-"
};
encryptedPartList.Add(encryptedPartExample);
```
```
let encrypted_parts_list = vec![
EncryptedPart::builder()
.name("standard_beacon_name")
.prefix("E-")
.build()?
];
```
**Liste de pièces signée**
Identifie les champs signés inclus dans la balise composée.
Les pièces signées sont facultatives. Vous pouvez configurer une balise composée qui ne fait référence à aucune pièce signée.
Chaque partie doit inclure un nom, une source et un préfixe. La source est le `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champ `SIGN_ONLY` ou que l'article identifie. La source doit être un nom de champ ou un index faisant référence à la valeur d'un champ imbriqué. Si le nom de votre pièce identifie la source, vous pouvez omettre la source et le SDK AWS de chiffrement de base de données utilisera automatiquement le nom comme source. Nous recommandons de spécifier la source comme nom de pièce dans la mesure du possible. Le préfixe peut être n'importe quelle chaîne, mais il doit être unique. Une pièce signée ne peut pas avoir le même préfixe qu'une pièce chiffrée. Nous recommandons d'utiliser une valeur courte qui distingue la pièce des autres parties desservies par la balise composée.
Nous vous recommandons de définir vos pièces signées de manière globale dans la mesure du possible. Vous pouvez envisager de définir une pièce signée localement si vous avez l'intention de ne l'utiliser que dans une seule balise composée. Une pièce signée définie localement ne peut pas avoir le même préfixe ou le même nom qu'une pièce signée définie globalement.
```
List signedPartList = new ArrayList<>();
SignedPart signedPartExample = SignedPart.builder()
.name("signedFieldName")
.prefix("S-")
.build();
signedPartList.add(signedPartExample);
```
```
var signedPartsList = new List
{
new SignedPart { Name = "signedFieldName1", Prefix = "S-" },
new SignedPart { Name = "signedFieldName2", Prefix = "SF-" }
};
```
```
let signed_parts_list = vec![
SignedPart::builder()
.name("signed_field_name_1")
.prefix("S-")
.build()?,
SignedPart::builder()
.name("signed_field_name_2")
.prefix("SF-")
.build()?,
];
```
**Liste des constructeurs**
Identifie les *constructeurs* qui définissent les différentes manières dont les pièces cryptées et signées peuvent être assemblées par la balise composée. Vous pouvez référencer des pièces locales et globales dans votre liste de constructeurs.
Si vous créez votre balise composée à partir de pièces chiffrées et signées définies globalement, vous devez fournir une liste de constructeurs.
Si vous n'utilisez aucune pièce chiffrée ou signée définie globalement pour construire votre balise composée, la liste des constructeurs est facultative. Si vous ne spécifiez pas de liste de constructeurs, le SDK AWS Database Encryption assemble la balise composée avec le constructeur par défaut suivant.
+ Toutes les pièces signées dans l'ordre dans lequel elles ont été ajoutées à la liste des pièces signées
+ Toutes les pièces cryptées dans l'ordre dans lequel elles ont été ajoutées à la liste des pièces cryptées
+ Toutes les pièces sont requises
**Constructeurs**
Chaque constructeur est une liste ordonnée de *pièces du constructeur* qui définit une manière dont la balise composée peut être assemblée. Les pièces du constructeur sont assemblées dans l'ordre dans lequel elles sont ajoutées à la liste, chaque partie étant séparée par le caractère divisé spécifié.
Chaque partie du constructeur nomme une partie chiffrée ou une partie signée, et définit si cette partie est obligatoire ou facultative dans le constructeur. Par exemple, si vous souhaitez interroger une balise composée sur`Field1`,`Field1.Field2`, et`Field1.Field2.Field3`, marquer `Field2` et `Field3` comme facultatif et créer un constructeur.
Chaque constructeur doit avoir au moins une pièce requise. Nous vous recommandons de rendre obligatoire la première partie de chaque constructeur afin que vous puissiez utiliser l'`BEGINS_WITH`opérateur dans vos requêtes.
Un constructeur réussit si toutes ses pièces requises sont présentes dans l'enregistrement. Lorsque vous écrivez un nouvel enregistrement, la balise composée utilise la liste des constructeurs pour déterminer si la balise peut être assemblée à partir des valeurs fournies. Il tente d'assembler la balise dans l'ordre dans lequel les constructeurs ont été ajoutés à la liste des constructeurs, et il utilise le premier constructeur qui réussit. Si aucun constructeur ne réussit, la balise n'est pas écrite dans l'enregistrement.
Tous les lecteurs et rédacteurs doivent spécifier le même ordre de constructeurs pour s'assurer que les résultats de leurs requêtes sont corrects.
Utilisez les procédures suivantes pour spécifier votre propre liste de constructeurs.
1. Créez une partie constructeur pour chaque pièce chiffrée et pièce signée afin de définir si cette partie est requise ou non.
Le nom de la partie constructeur doit être le nom de la balise standard ou du champ signé qu'il représente.
------
#### [ Java ]
```
ConstructorPart field1ConstructorPart = ConstructorPart.builder()
.name("Field1")
.required(true)
.build();
```
------
#### [ C\$1 / .NET ]
```
var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true };
```
------
#### [ Rust ]
```
let field_1_constructor_part = ConstructorPart::builder()
.name("field_1")
.required(true)
.build()?;
```
------
1. Créez un constructeur pour chaque manière possible d'assembler la balise composée à l'aide des pièces du constructeur que vous avez créées à l'**étape** 1.
Par exemple, si vous souhaitez effectuer une requête sur `Field1.Field2.Field3` et`Field4.Field2.Field3`, vous devez créer deux constructeurs. `Field1`et `Field4` peuvent tous deux être requis car ils sont définis dans deux constructeurs distincts.
------
#### [ Java ]
```
// Create a list for Field1.Field2.Field3 queries
List field123ConstructorPartList = new ArrayList<>();
field123ConstructorPartList.add(field1ConstructorPart);
field123ConstructorPartList.add(field2ConstructorPart);
field123ConstructorPartList.add(field3ConstructorPart);
Constructor field123Constructor = Constructor.builder()
.parts(field123ConstructorPartList)
.build();
// Create a list for Field4.Field2.Field1 queries
List field421ConstructorPartList = new ArrayList<>();
field421ConstructorPartList.add(field4ConstructorPart);
field421ConstructorPartList.add(field2ConstructorPart);
field421ConstructorPartList.add(field1ConstructorPart);
Constructor field421Constructor = Constructor.builder()
.parts(field421ConstructorPartList)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a list for Field1.Field2.Field3 queries
var field123ConstructorPartList = new Constructor
{
Parts = new List { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart }
};
// Create a list for Field4.Field2.Field1 queries
var field421ConstructorPartList = new Constructor
{
Parts = new List { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart }
};
```
------
#### [ Rust ]
```
// Create a list for field1.field2.field3 queries
let field1_field2_field3_constructor = Constructor::builder()
.parts(vec![
field1_constructor_part,
field2_constroctor_part.clone(),
field3_constructor_part,
])
.build()?;
// Create a list for field4.field2.field1 queries
let field4_field2_field1_constructor = Constructor::builder()
.parts(vec![
field4_constructor_part,
field2_constroctor_part.clone(),
field1_constructor_part,
])
.build()?;
```
------
1. Créez une liste de constructeurs qui inclut tous les constructeurs que vous avez créés à l'**étape** 2.
------
#### [ Java ]
```
List constructorList = new ArrayList<>();
constructorList.add(field123Constructor);
constructorList.add(field421Constructor);
```
------
#### [ C\$1 / .NET ]
```
var constructorList = new List
{
field123Constructor,
field421Constructor
};
```
------
#### [ Rust ]
```
let constructor_list = vec![
field1_field2_field3_constructor,
field4_field2_field1_constructor,
];
```
------
1. Spécifiez le `constructorList` moment où vous créez votre balise composée.
# Exemples de configuration
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Les exemples suivants montrent comment configurer des balises standard et composées. Les configurations suivantes ne fournissent pas de longueur de balise. Pour obtenir de l'aide pour déterminer la longueur de balise adaptée à votre configuration, voir [Choisir une longueur de balise](choosing-beacon-length.md).
Pour voir des exemples de code complets qui montrent comment configurer et utiliser des balises, consultez les exemples de chiffrement consultables [Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption), [.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/) et [Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/) dans le référentiel aws-database-encryption-sdk -dynamodb sur. GitHub
**Topics**
+ [Balises standard](#standard-config-examples)
+ [Balises composées](#compound-config-examples)
## Balises standard
Si vous souhaitez interroger le `inspector_id_last4` champ pour obtenir des correspondances exactes, créez une balise standard en utilisant la configuration suivante.
------
#### [ Java ]
```
List standardBeaconList = new ArrayList<>();
StandardBeacon exampleStandardBeacon = StandardBeacon.builder()
.name("inspector_id_last4")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(exampleStandardBeacon);
```
------
#### [ C\$1 / .NET ]
```
var standardBeaconList = new List>);
StandardBeacon exampleStandardBeacon = new StandardBeacon
{
Name = "inspector_id_last4",
Length = 10
};
standardBeaconList.Add(exampleStandardBeacon);
```
------
#### [ Rust ]
```
let last4_beacon = StandardBeacon::builder()
.name("inspector_id_last4")
.length(10)
.build()?;
let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?;
let standard_beacon_list = vec![last4_beacon, unit_beacon];
```
------
## Balises composées
Si vous souhaitez interroger la `UnitInspection` base de données sur `inspector_id_last4` et`inspector_id_last4.unit`, créez une balise composée avec la configuration suivante. Cette balise composée ne nécessite que des [parties cryptées](configure-beacons.md#encrypted-parts).
------
#### [ Java ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
List standardBeaconList = new ArrayList<>();
StandardBeacon inspectorBeacon = StandardBeacon.builder()
.name("inspector_id_last4")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(inspectorBeacon);
StandardBeacon unitBeacon = StandardBeacon.builder()
.name("unit")
.length(beaconLengthInBits)
.build();
standardBeaconList.add(unitBeacon);
// 2. Define the encrypted parts.
List encryptedPartList = new ArrayList<>();
// Each encrypted part needs a name and prefix
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
EncryptedPart encryptedPartInspector = EncryptedPart.builder()
.name("inspector_id_last4")
.prefix("I-")
.build();
encryptedPartList.add(encryptedPartInspector);
EncryptedPart encryptedPartUnit = EncryptedPart.builder()
.name("unit")
.prefix("U-")
.build();
encryptedPartList.add(encryptedPartUnit);
// 3. Create the compound beacon.
// This compound beacon only requires a name, split character,
// and list of encrypted parts
CompoundBeacon inspectorUnitBeacon = CompoundBeacon.builder()
.name("inspectorUnitBeacon")
.split(".")
.sensitive(encryptedPartList)
.build();
```
------
#### [ C\$1 / .NET ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
StandardBeacon inspectorBeacon = new StandardBeacon
{
Name = "inspector_id_last4",
Length = 10
};
standardBeaconList.Add(inspectorBeacon);
StandardBeacon unitBeacon = new StandardBeacon
{
Name = "unit",
Length = 30
};
standardBeaconList.Add(unitBeacon);
// 2. Define the encrypted parts.
var last4EncryptedPart = new EncryptedPart
// Each encrypted part needs a name and prefix
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
var last4EncryptedPart = new EncryptedPart
{
Name = "inspector_id_last4",
Prefix = "I-"
};
encryptedPartList.Add(last4EncryptedPart);
var unitEncryptedPart = new EncryptedPart
{
Name = "unit",
Prefix = "U-"
};
encryptedPartList.Add(unitEncryptedPart);
// 3. Create the compound beacon.
// This compound beacon only requires a name, split character,
// and list of encrypted parts
var compoundBeaconList = new List>);
var inspectorCompoundBeacon = new CompoundBeacon
{
Name = "inspector_id_last4",
Split = ".",
Encrypted = encryptedPartList
};
compoundBeaconList.Add(inspectorCompoundBeacon);
```
------
#### [ Rust ]
```
// 1. Create standard beacons for the inspector_id_last4 and unit fields.
let last4_beacon = StandardBeacon::builder()
.name("inspector_id_last4")
.length(10)
.build()?;
let unit_beacon = StandardBeacon::builder().name("unit").length(30).build()?;
let standard_beacon_list = vec![last4_beacon, unit_beacon];
// 2. Define the encrypted parts.
// The name must be the name of the standard beacon
// The prefix must be unique
// For this example we use the prefix "I-" for "inspector_id_last4"
// and "U-" for "unit"
let encrypted_parts_list = vec![
EncryptedPart::builder()
.name("inspector_id_last4")
.prefix("I-")
.build()?,
EncryptedPart::builder().name("unit").prefix("U-").build()?,
];
// 3. Create the compound beacon
// This compound beacon only requires a name, split character,
// and list of encrypted parts
let compound_beacon_list = vec![CompoundBeacon::builder()
.name("last4UnitCompound")
.split(".")
.encrypted(encrypted_parts_list)
.build()?];
```
------
# Utilisation de balises
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Les balises vous permettent de rechercher des enregistrements cryptés sans déchiffrer l'intégralité de la base de données interrogée. Les balises sont conçues pour être implémentées dans de nouvelles bases de données non peuplées. Toute balise configurée dans une base de données existante ne mappera que les nouveaux enregistrements écrits dans la base de données. Les balises sont calculées à partir de la valeur en texte brut d'un champ. Une fois le champ crypté, la balise ne peut plus cartographier les données existantes. Une fois que vous avez écrit de nouveaux enregistrements avec une balise, vous ne pouvez pas mettre à jour la configuration de la balise. Cependant, vous pouvez ajouter de nouvelles balises pour les nouveaux champs que vous ajoutez à votre enregistrement.
Après avoir configuré vos balises, vous devez suivre les étapes suivantes avant de commencer à remplir votre base de données et à exécuter des requêtes sur vos balises.
1. **Création d'un porte-clés AWS KMS hiérarchique**
Pour utiliser le chiffrement consultable, vous devez utiliser le trousseau de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md) pour générer, chiffrer et déchiffrer les [clés de données](concepts.md#data-key) utilisées pour protéger vos enregistrements.
Après avoir configuré vos balises, assemblez les [prérequis relatifs au jeu de clés hiérarchique](use-hierarchical-keyring.md#hierarchical-keyring-prereqs) et [créez votre](use-hierarchical-keyring.md#initialize-hierarchical-keyring) trousseau de clés hiérarchique.
Pour plus de détails sur les raisons pour lesquelles le trousseau de clés hiérarchique est requis, voir [Utilisation du trousseau de clés hiérarchique pour le chiffrement consultable](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
1.
**Définissez la version de la balise**
Spécifiez votre `keyStore``keySource`, une liste de toutes les balises standard que vous avez configurées, une liste de toutes les balises composées que vous avez configurées, une liste de parties cryptées, une liste de parties signées et une version de balise. Vous devez spécifier `1` la version de la balise. Pour obtenir des conseils sur la définition de votre`keySource`, voir[Définition de la source clé de votre balise](use-hierarchical-keyring.md#beacon-key-source).
L'exemple Java suivant définit la version de balise pour une base de données à locataire unique. Pour obtenir de l'aide sur la définition de la version de balise pour une base de données mutualisée, consultez la section [Chiffrement consultable pour les bases de données mutualisées](searchable-encryption-multitenant.md).
------
#### [ Java ]
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.encryptedParts(encryptedPartsList)
.signedParts(signedPartsList)
.version(1) // MUST be 1
.keyStore(keyStore)
.keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branchKeyId)
.cacheTTL(6000)
.build())
.build())
.build()
);
```
------
#### [ C\$1 / .NET ]
```
var beaconVersions = new List
{
new BeaconVersion
{
StandardBeacons = standardBeaconList,
CompoundBeacons = compoundBeaconList,
EncryptedParts = encryptedPartsList,
SignedParts = signedPartsList,
Version = 1, // MUST be 1
KeyStore = branchKeyStoreName,
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000
}
}
}
};
```
------
#### [ Rust ]
```
let beacon_version = BeaconVersion::builder()
.standard_beacons(standard_beacon_list)
.compound_beacons(compound_beacon_list)
.version(1) // MUST be 1
.key_store(key_store.clone())
.key_source(BeaconKeySource::Single(
SingleKeyStore::builder()
// `keyId` references a beacon key.
// For every branch key we create in the keystore,
// we also create a beacon key.
// This beacon key is not the same as the branch key,
// but is created with the same ID as the branch key.
.key_id(branch_key_id)
.cache_ttl(6000)
.build()?,
))
.build()?;
let beacon_versions = vec![beacon_version];
```
------
1. **Configuration des index secondaires**
Après avoir [configuré vos balises](configure-beacons.md), vous devez configurer un index secondaire qui reflète chaque balise avant de pouvoir effectuer une recherche dans les champs chiffrés. Pour de plus amples informations, veuillez consulter [Configuration des index secondaires avec des balises](ddb-searchable-encryption.md#ddb-beacon-indexes).
1. **Définissez vos actions [cryptographiques](concepts.md#crypt-actions)**
Tous les champs utilisés pour construire une balise standard doivent être marqués`ENCRYPT_AND_SIGN`. Tous les autres champs utilisés pour créer des balises doivent être marqués `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
1. **Configuration d'un client SDK AWS de chiffrement de base de données**
Pour configurer un client du SDK AWS de chiffrement de base de données qui protège les éléments de table de votre table DynamoDB, [consultez la section Bibliothèque de chiffrement côté client Java](ddb-java.md) pour DynamoDB.
## Interrogation de balises
Le type de balise que vous configurez détermine le type de requêtes que vous pouvez effectuer. Les balises standard utilisent des expressions de filtre pour effectuer des recherches d'égalité. Les balises composées combinent des chaînes de texte en clair littérales et des balises standard pour effectuer des requêtes complexes. Lorsque vous interrogez des données chiffrées, vous recherchez le nom de la balise.
Vous ne pouvez pas comparer les valeurs de deux balises standard, même si elles contiennent le même texte brut sous-jacent. Les deux balises standard produiront deux balises HMAC différentes pour les mêmes valeurs en texte brut. Par conséquent, les balises standard ne peuvent pas effectuer les requêtes suivantes.
+ `beacon1 = beacon2`
+ `beacon1 IN (beacon2)`
+ `value IN (beacon1, beacon2, ...)`
+ `CONTAINS(beacon1, beacon2)`
Les balises composées peuvent effectuer les requêtes suivantes.
+ `BEGINS_WITH(a)`, où `a` reflète la valeur totale du champ par lequel commence la balise composée assemblée. Vous ne pouvez pas utiliser l'`BEGINS_WITH`opérateur pour identifier une valeur commençant par une sous-chaîne particulière. Cependant, vous pouvez utiliser « `BEGINS_WITH(S_)` where » `S_` reflète le préfixe d'une pièce par laquelle commence la balise composée assemblée.
+ `CONTAINS(a)`, où `a` reflète la valeur totale d'un champ que contient la balise composée assemblée. Vous ne pouvez pas utiliser l'`CONTAINS`opérateur pour identifier un enregistrement contenant une sous-chaîne particulière ou une valeur au sein d'un ensemble.
Par exemple, vous ne pouvez pas exécuter une `CONTAINS(path, "a"` requête `a` qui reflète la valeur d'un ensemble.
+ Vous pouvez comparer les [parties signées](configure-beacons.md#signed-parts) de balises composées. Lorsque vous comparez des parties signées, vous pouvez éventuellement ajouter le préfixe d'une [partie chiffrée](configure-beacons.md#encrypted-parts) à une ou plusieurs parties signées, mais vous ne pouvez inclure la valeur d'un champ crypté dans aucune requête.
Par exemple, vous pouvez comparer des pièces signées et effectuer une requête sur `signedField1 = signedField2` ou`value IN (signedField1, signedField2, ...)`.
Vous pouvez également comparer les parties signées et le préfixe d'une pièce chiffrée en effectuant une requête sur`signedField1.A_ = signedField2.B_`.
+ `field BETWEEN a AND b`, où `a` et `b` sont des pièces signées. Vous pouvez éventuellement ajouter le préfixe d'une partie chiffrée à une ou plusieurs parties signées, mais vous ne pouvez inclure la valeur d'un champ crypté dans aucune requête.
Vous devez inclure le préfixe pour chaque partie que vous incluez dans une requête sur une balise composée. Par exemple, si vous avez créé une balise composée`compoundBeacon`, à partir de deux champs, `encryptedField` et`signedField`, vous devez inclure les préfixes configurés pour ces deux parties lorsque vous interrogez la balise.
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```
# Chiffrement consultable pour les bases de données mutualisées
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
Pour implémenter le chiffrement consultable dans votre base de données, vous devez utiliser un trousseau de [clés AWS KMS hiérarchique](use-hierarchical-keyring.md). Le trousseau de clés AWS KMS hiérarchique génère, chiffre et déchiffre les clés de données utilisées pour protéger vos dossiers. Il crée également la clé de balise utilisée pour générer des balises. Lorsque vous utilisez le trousseau de clés AWS KMS hiérarchique avec des bases de données à locataires multiples, il existe une clé de branche et une clé de balise distinctes pour chaque locataire. Pour interroger des données chiffrées dans une base de données mutualisée, vous devez identifier les éléments clés de balise utilisés pour générer la balise que vous interrogez. Pour de plus amples informations, veuillez consulter [Utilisation du trousseau de clés hiérarchique pour un chiffrement consultable](use-hierarchical-keyring.md#searchable-encryption-hierarchical-keyrings).
Lorsque vous définissez la [version de balise](using-beacons.md#beacon-version) pour une base de données mutualisée, spécifiez une liste de toutes les balises standard que vous avez configurées, une liste de toutes les balises composées que vous avez configurées, une version de balise et un. `keySource` Vous devez [définir votre source de clé de balise](use-hierarchical-keyring.md#beacon-key-source) comme une `MultiKeyStore` durée de vie du cache de clé de balise local et inclure une taille de cache maximale pour le cache de clé de balise local. `keyFieldName`
Si vous avez configuré des [balises signées](configure.md#signed-beacons), elles doivent être incluses dans votre`compoundBeaconList`. Les balises signées sont un type de balise composée qui indexe et exécute des requêtes complexes sur des `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champs `SIGN_ONLY` et des champs.
------
#### [ Java ]
```
List beaconVersions = new ArrayList<>();
beaconVersions.add(
BeaconVersion.builder()
.standardBeacons(standardBeaconList)
.compoundBeacons(compoundBeaconList)
.version(1) // MUST be 1
.keyStore(branchKeyStoreName)
.keySource(BeaconKeySource.builder()
.multi(MultiKeyStore.builder()
.keyFieldName(keyField)
.cacheTTL(6000)
.maxCacheSize(10)
.build())
.build())
.build()
);
```
------
#### [ C\$1 / .NET ]
```
var beaconVersions = new List
{
new BeaconVersion
{
StandardBeacons = standardBeaconList,
CompoundBeacons = compoundBeaconList,
EncryptedParts = encryptedPartsList,
SignedParts = signedPartsList,
Version = 1, // MUST be 1
KeyStore = branchKeyStoreName,
KeySource = new BeaconKeySource
{
Multi = new MultiKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000,
MaxCacheSize = 10
}
}
}
};
```
------
#### [ Rust ]
```
let beacon_version = BeaconVersion::builder()
.standard_beacons(standard_beacon_list)
.compound_beacons(compound_beacon_list)
.version(1) // MUST be 1
.key_store(key_store.clone())
.key_source(BeaconKeySource::Multi(
MultiKeyStore::builder()
// `keyId` references a beacon key.
// For every branch key we create in the keystore,
// we also create a beacon key.
// This beacon key is not the same as the branch key,
// but is created with the same ID as the branch key.
.key_id(branch_key_id)
.cache_ttl(6000)
.max_cache_size(10)
.build()?,
))
.build()?;
let beacon_versions = vec![beacon_version];
```
------
**keyFieldName**
[`keyFieldName`](use-hierarchical-keyring.md#keyFieldName)Définit le nom du champ qui stocke la clé `branch-key-id` associée à la balise utilisée pour générer des balises pour un locataire donné.
Lorsque vous écrivez de nouveaux enregistrements dans votre base de données, la clé `branch-key-id` identifiant la clé de balise utilisée pour générer des balises pour cet enregistrement est stockée dans ce champ.
Par défaut, il `keyField` s'agit d'un champ conceptuel qui n'est pas explicitement stocké dans votre base de données. Le SDK AWS de chiffrement de base de données identifie la [clé `branch-key-id` de données chiffrée contenue](concepts.md#data-key) dans la [description du matériel](concepts.md#material-description) et stocke la valeur dans le concept afin que vous `keyField` puissiez la référencer dans vos balises composées et vos balises [signées](configure.md#signed-beacons). Puisque la description du matériau est signée, le concept `keyField` est considéré comme une partie signée.
Vous pouvez également inclure le `keyField` dans vos actions cryptographiques sous forme de `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` champ `SIGN_ONLY` ou pour le stocker explicitement dans votre base de données. Dans ce cas, vous devez l'inclure manuellement `keyField` chaque fois que vous écrivez un enregistrement `branch-key-id` dans votre base de données.
## Interrogation de balises dans une base de données mutualisée
Pour interroger une balise, vous devez l'inclure `keyField` dans votre requête afin d'identifier les éléments clés de balise appropriés nécessaires pour recalculer la balise. Vous devez spécifier le code `branch-key-id` associé à la clé de balise utilisée pour générer les balises d'un enregistrement. Vous ne pouvez pas spécifier le [nom convivial](use-hierarchical-keyring.md#branch-key-id-supplier) qui identifie un locataire `branch-key-id` dans le fournisseur d'ID de clé de succursale. Vous pouvez les inclure `keyField` dans vos requêtes de différentes manières.
**Balises composées**
Que vous les stockiez explicitement ou non `keyField` dans vos dossiers, vous pouvez les inclure `keyField` directement dans vos balises composées sous forme de pièce signée. La pièce `keyField` signée doit être requise.
Par exemple, si vous souhaitez créer une balise composée`compoundBeacon`, à partir de deux champs`signedField`, `encryptedField` vous devez également l'inclure `keyField` sous forme de pièce signée. Cela vous permet d'effectuer la requête suivante sur`compoundBeacon`.
```
compoundBeacon = E_encryptedFieldValue.S_signedFieldValue.K_branch-key-id
```
**Balises signées**
Le SDK AWS Database Encryption utilise des balises standard et composées pour fournir des solutions de chiffrement consultables. Ces balises doivent inclure au moins un champ crypté. Cependant, le SDK AWS Database Encryption prend également en charge les [balises signées](configure.md#signed-beacons) qui peuvent être entièrement configurées à partir de texte brut `SIGN_ONLY` et de champs. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Les balises signées peuvent être construites à partir d'une seule pièce. Que vous le stockiez explicitement `keyField` dans vos dossiers ou non, vous pouvez créer une balise signée à partir de celle-ci `keyField` et l'utiliser pour créer des requêtes composées combinant une requête sur la balise `keyField` signée avec une requête sur l'une de vos autres balises. Par exemple, vous pouvez exécuter la requête suivante.
```
keyField = K_branch-key-id AND compoundBeacon = E_encryptedFieldValue.S_signedFieldValue
```
Pour obtenir de l'aide sur la configuration des balises signées, voir [Création de balises signées](configure.md#signed-beacons)
**Interrogez directement sur le `keyField`**
Si vous l'avez spécifié `keyField` dans vos actions cryptographiques et que vous stockez explicitement le champ dans votre enregistrement, vous pouvez créer une requête composée qui combine une requête sur votre balise avec une requête sur le`keyField`. Vous pouvez choisir d'effectuer une requête directement sur le `keyField` si vous souhaitez interroger une balise standard. Par exemple, vous pouvez exécuter la requête suivante.
```
keyField = branch-key-id AND standardBeacon = S_standardBeaconValue
```