Configuration du chiffrement de AWS base de données SDK - AWS Chiffrement des bases SDK
Sélection d'un langage de programmationSélection des clés d'emballageCréation d'un filtre de découverteUtilisation de bases de données mutualiséesCréation de balises signées

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.

Configuration du chiffrement de AWS base de données SDK

Notre bibliothèque de chiffrement côté client a été renommée AWS Database Encryption. SDK Ce guide du développeur fournit toujours des informations sur le client de chiffrement DynamoDB.

Le chiffrement AWS de base de données SDK est conçu pour être facile à utiliser. Bien que le chiffrement AWS de base de données SDK comporte plusieurs options de configuration, les valeurs par défaut sont soigneusement choisies pour être pratiques et sécurisées pour la plupart des applications. Toutefois, vous devrez peut-être ajuster votre configuration pour améliorer les performances ou inclure une fonctionnalité personnalisée dans votre conception.

Sélection d'un langage de programmation

Le chiffrement AWS de base de données SDK pour DynamoDB est disponible dans plusieurs langages de programmation. Les implémentations du langage sont conçues pour être totalement interopérables et pour offrir les mêmes fonctionnalités, bien qu'elles puissent être implémentées de différentes manières. Généralement, vous utilisez la bibliothèque compatible avec votre application.

Sélection des clés d'emballage

Le chiffrement AWS de base de données SDK génère une clé de données symétrique unique pour chiffrer chaque champ. Vous n'avez pas besoin de configurer, de gérer ou d'utiliser les clés de données. Le chiffrement AWS de base de données le SDK fait pour vous.

Toutefois, vous devez sélectionner une ou plusieurs clés d'encapsulation pour chiffrer chaque clé de données. Le chiffrement AWS de base de données SDK prend en charge AWS Key Management Service(AWS KMS) les clés de chiffrement symétriques et KMS les clés asymétriques RSAKMS. Il prend également en charge les clés AES symétriques et RSA asymétriques que vous fournissez en différentes tailles. Vous êtes responsable de la sécurité et de la durabilité de vos clés d'encapsulage. Nous vous recommandons donc d'utiliser une clé de chiffrement dans un module de sécurité matériel ou un service d'infrastructure clé, tel que AWS KMS.

Pour spécifier vos clés d'encapsulation pour le chiffrement et le déchiffrement, vous utilisez un trousseau de clés. Selon le type de trousseau de clés que vous utilisez, vous pouvez spécifier une clé d'encapsulation ou plusieurs clés d'encapsulation de types identiques ou différents. Si vous utilisez plusieurs clés d'encapsulation pour encapsuler une clé de données, chaque clé d'encapsulation chiffrera une copie de la même clé de données. Les clés de données cryptées (une par clé d'encapsulage) sont stockées dans la description du matériau stockée à côté du champ crypté. Pour déchiffrer les données, le chiffrement de AWS base de données SDK doit d'abord utiliser l'une de vos clés d'encapsulation pour déchiffrer une clé de données cryptée.

Nous vous recommandons d'utiliser l'un des AWS KMS porte-clés dans la mesure du possible. Le chiffrement AWS de base de données SDK fournit le AWS KMS trousseau de clés et le trousseau de clés AWS KMS hiérarchique, ce qui réduit le nombre d'appels effectués à. AWS KMS Pour spécifier un AWS KMS key dans un trousseau de clés, utilisez un identifiant de AWS KMS clé compatible. Si vous utilisez le trousseau de clés AWS KMS hiérarchique, vous devez spécifier la cléARN. Pour plus de détails sur les identificateurs de clé d'une AWS KMS clé, consultez la section Identifiants de clé dans le guide du AWS Key Management Service développeur.

  • Lorsque vous chiffrez avec un AWS KMS trousseau de clés, vous pouvez spécifier n'importe quel identifiant de clé valide (cléARN, nom d'aliasARN, alias ou ID de clé) pour une clé de chiffrement symétrique. KMS Si vous utilisez une RSA KMS clé asymétrique, vous devez spécifier la cléARN.

    Si vous spécifiez un nom d'alias ou un alias ARN pour une KMS clé lors du chiffrement, le chiffrement AWS de base de données SDK enregistre la clé ARN actuellement associée à cet alias ; il n'enregistre pas l'alias. Les modifications apportées à l'alias n'affectent pas la KMS clé utilisée pour déchiffrer vos clés de données.

  • Par défaut, le AWS KMS trousseau de clés déchiffre les enregistrements en mode strict (où vous spécifiez des clés particulières). KMS Vous devez utiliser une clé ARN pour vous identifier en vue AWS KMS keys du déchiffrement.

    Lorsque vous chiffrez avec un AWS KMS trousseau de clés, le chiffrement AWS de base de données SDK stocke la clé ARN du AWS KMS key dans la description du matériel avec la clé de données cryptée. Lors du déchiffrement en mode strict, le chiffrement de AWS base de données SDK vérifie que la même clé ARN apparaît dans le jeu de clés avant de tenter d'utiliser la clé d'encapsulation pour déchiffrer la clé de données cryptée. Si vous utilisez un identifiant de clé différent, le chiffrement AWS SDK de base de données ne le reconnaîtra ni ne l'utilisera AWS KMS key, même si les identifiants font référence à la même clé.

  • Lors du déchiffrement en mode découverte, vous ne spécifiez aucune clé d'encapsulation. Tout d'abord, le chiffrement AWS de base de données SDK tente de déchiffrer l'enregistrement à l'aide de la clé ARN stockée dans la description du matériel. Si cela ne fonctionne pas, le chiffrement de AWS base de données SDK demande de déchiffrer l'enregistrement AWS KMS à l'aide de la KMS clé qui l'a chiffré, quel que soit le propriétaire ou le détenteur de cette KMS clé.

Pour spécifier une AESclé brute ou une paire de RSA clés brutes en tant que clé d'encapsulation dans un trousseau de clés, vous devez spécifier un espace de noms et un nom. Lors du déchiffrement, vous devez utiliser exactement le même espace de noms et le même nom pour chaque clé d'encapsulation brute que ceux que vous avez utilisés lors du chiffrement. Si vous utilisez un espace de noms ou un nom différent, le chiffrement SDK de AWS base de données ne reconnaîtra ni n'utilisera la clé d'encapsulation, même si le contenu de la clé est le même.

Création d'un filtre de découverte

Lorsque vous déchiffrez des données chiffrées à l'aide de KMS clés, il est recommandé de les déchiffrer en mode strict, c'est-à-dire de limiter les clés d'encapsulation utilisées à celles que vous spécifiez. Toutefois, si nécessaire, vous pouvez également déchiffrer en mode découverte, dans lequel vous ne spécifiez aucune clé d'encapsulation. Dans ce mode, AWS KMS vous pouvez déchiffrer la clé de données cryptée à l'aide de la KMS clé qui l'a chiffrée, indépendamment de qui possède ou a accès à cette KMS clé.

Si vous devez déchiffrer en mode découverte, nous vous recommandons de toujours utiliser un filtre de découverte, qui limite les KMS clés pouvant être utilisées à celles d'une partition Compte AWS et spécifiée. Le filtre de découverte est facultatif, mais il s'agit d'une bonne pratique.

Utilisez le tableau suivant pour déterminer la valeur de partition de votre filtre de découverte.

Région Partition
Régions AWS aws
Régions Chine aws-cn
AWS GovCloud (US) Regions aws-us-gov

L'exemple suivant montre comment créer un filtre de découverte. Avant d'utiliser le code, remplacez les valeurs d'exemple par des valeurs valides pour votre partition Compte AWS and.

Java
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
C# / .NET
var discoveryFilter = new DiscoveryFilter
{
    Partition = "aws",
    AccountIds = 111122223333
};

Utilisation de bases de données mutualisées

Avec le chiffrement AWS de base de donnéesSDK, vous pouvez configurer le chiffrement côté client pour les bases de données avec un schéma partagé en isolant chaque locataire avec des matériaux de chiffrement distincts. Lorsque vous envisagez une base de données mutualisée, prenez le temps de passer en revue vos exigences en matière de sécurité et l'impact potentiel de la mutualisation sur celles-ci. Par exemple, l'utilisation d'une base de données mutualisée peut avoir un impact sur votre capacité à combiner le chiffrement AWS de base de données SDK avec une autre solution de chiffrement côté serveur.

Si plusieurs utilisateurs effectuent des opérations de chiffrement dans votre base de données, vous pouvez utiliser l'un des AWS KMS trousseaux de clés pour fournir à chaque utilisateur une clé distincte à utiliser dans ses opérations cryptographiques. La gestion des clés de données pour une solution de chiffrement multi-locataires côté client peut s'avérer complexe. Nous vous recommandons d'organiser vos données par locataire dans la mesure du possible. Si le locataire est identifié par les valeurs des clés primaires (par exemple, la clé de partition dans une table Amazon DynamoDB), la gestion de vos clés est plus simple.

Vous pouvez utiliser le AWS KMS trousseau de clés pour isoler chaque locataire à l'aide d'un trousseau de AWS KMS clés distinct et. AWS KMS keys En fonction du volume d' AWS KMS appels effectués par locataire, vous pouvez utiliser le trousseau de clés AWS KMS hiérarchique pour minimiser le nombre d'appels adressés à AWS KMS. Le trousseau de clés AWS KMS hiérarchique est une solution de mise en cache des matériaux cryptographiques qui réduit le nombre d' AWS KMS appels en utilisant des clés de branche AWS KMS protégées conservées dans une table Amazon DynamoDB, puis en mettant en cache localement les éléments clés de branche utilisés dans les opérations de chiffrement et de déchiffrement. Vous devez utiliser le trousseau de clés AWS KMS hiérarchique pour implémenter le chiffrement consultable dans votre base de données.

Création de balises signées

Le chiffrement AWS de base de données SDK utilise des balises standard et des balises composées pour fournir des solutions de chiffrement consultables qui vous permettent de rechercher des enregistrements cryptés sans déchiffrer l'intégralité de la base de données interrogée. Cependant, le chiffrement AWS de base de données prend SDK également en charge les balises signées qui peuvent être entièrement configurées à partir de champs signés en texte brut. 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.

Par exemple, si vous avez une base de données mutualisée, vous souhaiterez peut-être créer une balise signée qui vous permettra de rechercher dans votre base de données des enregistrements chiffrés par la clé d'un locataire spécifique. Pour de plus amples informations, veuillez consulter Interrogation de balises dans une base de données mutualisée.

Vous devez utiliser le trousseau de clés AWS KMS hiérarchique pour créer des balises signées.

Pour configurer une balise signée, fournissez les valeurs suivantes.

Java

Configuration de balise composée

L'exemple suivant définit les listes de pièces signées localement dans la configuration des balises signées.

List<CompoundBeacon> compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
    .name("compoundBeaconName")
    .split(".") 
    .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 signées globalement dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section Utilisation des balises.

 List<BeaconVersion> beaconVersions = new ArrayList<>();
beaconVersions.add(
    BeaconVersion.builder()
        .standardBeacons(standardBeaconList)
        .compoundBeacons(compoundBeaconList)
        .signedParts(signedPartList)
        .version(1) // MUST be 1
        .keyStore(keyStore)
        .keySource(BeaconKeySource.builder()
            .single(SingleKeyStore.builder()
                .keyId(branchKeyId)
                .cacheTTL(6000)
                .build())
            .build())
        .build()
);
C# / .NET

Voir l'exemple de code complet : BeaconConfig.cs

Configuration des balises signées

L'exemple suivant définit les listes de pièces signées localement dans la configuration des balises signées.

var compoundBeaconList = new List<CompoundBeacon>();       
var exampleCompoundBeacon = new CompoundBeacon
 {
    Name = "compoundBeaconName",
    Split = ".",
    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 signées globalement dans la version balise. Pour plus d'informations sur la définition de la version des balises, consultez la section Utilisation des balises.

var beaconVersions = new List<BeaconVersion>
{
    new BeaconVersion
    {
        StandardBeacons = standardBeaconList,
        CompoundBeacons = compoundBeaconList,
        SignedParts = signedPartsList,
        Version = 1, // MUST be 1
        KeyStore = keyStore,
        KeySource = new BeaconKeySource
        {
            Single = new SingleKeyStore
            {
                KeyId = branchKeyId,
                CacheTTL = 6000
            }
        }
    }
};

Vous pouvez définir vos pièces signées dans des listes définies localement ou globalement. Nous vous recommandons de définir vos pièces signées dans une liste globale dans la version balise dans la mesure du possible. En définissant les pièces signées de manière globale, vous pouvez définir chaque pièce 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 signée qu'une seule fois, vous pouvez la définir dans une liste locale dans la configuration des balises signées. Vous pouvez référencer des pièces locales et globales dans votre liste de constructeurs.

Si vous définissez vos listes de pièces signées globalement, vous devez fournir une liste de pièces du constructeur identifiant toutes les manières possibles dont la balise signée peut assembler les champs dans la configuration de votre balise.

Note

Pour définir des listes de pièces signées de manière globale, vous devez utiliser la version 3.2 ou ultérieure du chiffrement de AWS base de donnéesSDK. 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 signées de manière globale.

Nom de la balise

Le nom que vous utilisez lorsque vous interrogez la balise.

Le nom d'une balise signé 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.

Personnage divisé

Le caractère utilisé pour séparer les parties qui composent votre balise signée.

Le caractère divisé ne peut apparaître dans les valeurs en texte brut d'aucun des champs à partir desquels la balise signée est construite.

Liste de pièces signée

Identifie les champs signés inclus dans la balise 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 chiffrement AWS de base de données SDK 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. Deux parties signées d'une balise signée ne peuvent pas avoir le même préfixe. 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 définie localement ne peut pas avoir le même préfixe ou le même nom qu'une pièce définie globalement.

Java
List<SignedPart> signedPartList = new ArrayList<>);
    SignedPart signedPartExample = SignedPart.builder()
        .name("signedFieldName")
        .prefix("S-")
        .build();
    signedPartList.add(signedPartExample);
C# / .NET
var signedPartsList = new List<SignedPart>
{
    new SignedPart { Name = "signedFieldName1", Prefix = "S-" },
    new SignedPart { Name = "signedFieldName2", Prefix = "SF-" }
};
Liste des constructeurs (facultatif)

Identifie les constructeurs qui définissent les différentes manières dont les pièces signées peuvent être assemblées par la balise signée.

Si vous ne spécifiez pas de liste de constructeurs, le chiffrement AWS de base de données SDK assemble la balise signé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 sont requises

Constructeurs

Chaque constructeur est une liste ordonnée de pièces du constructeur qui définit une manière dont la balise signé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 pièce signée et définit si cette partie est obligatoire ou facultative dans le constructeur. Par exemple, si vous souhaitez interroger une balise signée surField1,Field1.Field2, etField1.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_WITHopé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 signé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 pièce constructeur pour chaque pièce signée afin de définir si cette pièce est requise ou non.

    Le nom de la partie constructeur doit être le nom du champ signé.

    L'exemple suivant montre comment créer une partie constructeur pour un champ signé.

    Java
    ConstructorPart field1ConstructorPart = ConstructorPart.builder()
        .name("Field1")
        .required(true)
        .build();
    C# / .NET
    var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true };

  2. Créez un constructeur pour chaque manière possible d'assembler la balise signé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 etField4.Field2.Field3, vous devez créer deux constructeurs. Field1et 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<ConstructorPart> 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<ConstructorPart> field421ConstructorPartList = new ArrayList<>();
field421ConstructorPartList.add(field4ConstructorPart);
field421ConstructorPartList.add(field2ConstructorPart);
field421ConstructorPartList.add(field1ConstructorPart);
Constructor field421Constructor = Constructor.builder()
        .parts(field421ConstructorPartList)
        .build();
    C# / .NET
    // Create a list for Field1.Field2.Field3 queries
 var field123ConstructorPartList = new Constructor
{
    Parts = new List<ConstructorPart> { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart }
};
// Create a list for Field4.Field2.Field1 queries        
var field421ConstructorPartList = new Constructor
{
    Parts = new List<ConstructorPart> { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart }
};

  3. Créez une liste de constructeurs qui inclut tous les constructeurs que vous avez créés à l'étape 2.

    Java
    List<Constructor> constructorList = new ArrayList<>();
constructorList.add(field123Constructor)
constructorList.add(field421Constructor)
    C# / .NET
    var constructorList = new List<Constructor>
{
    field123Constructor,
    field421Constructor
};

  4. Spécifiez le constructorList moment où vous créez votre balise signée.

Afficher plusAfficher moins