View a markdown version of this page

Configuration de la   AWS SDK de chiffrement de base de données - AWS SDK de chiffrement de base de données
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 de la   AWS SDK de chiffrement de base de données

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 SDK AWS Database Encryption est conçu pour être facile à utiliser. Bien que le SDK AWS Database Encryption propose plusieurs options de configuration, les valeurs par défaut sont soigneusement choisies pour être pratiques et sécurisées pour la plupart des applications. Cependant, 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 SDK AWS de chiffrement de base de données 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. En règle générale, vous utilisez la bibliothèque compatible avec votre application.

Sélection des clés d'emballage

Le SDK AWS Database Encryption 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 SDK AWS Database Encryption le fait pour vous.

Vous devez toutefois sélectionner une ou plusieurs clés d'encapsulage pour chiffrer chaque clé de données. Le SDK AWS de chiffrement de base de données prend en charge AWS Key Management Service (AWS KMS) les clés KMS de chiffrement symétrique et les clés KMS RSA asymétriques. Il prend également en charge les clés symétriques AES et les clés asymétriques RSA que vous fournissez en différentes tailles. Vous êtes responsable de la sécurité et de la durabilité de vos clés d'emballage. Nous vous recommandons donc d'utiliser une clé de chiffrement dans un module de sécurité matériel ou dans 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 porte-clés que vous utilisez, vous pouvez spécifier une ou plusieurs clés d'encapsulage 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'emballage) sont stockées dans la description du matériau stockée à côté du champ crypté. Pour déchiffrer les données, le SDK AWS Database Encryption doit d'abord utiliser l'une de vos clés d'encapsulage pour déchiffrer une clé de données chiffrée.

Nous vous recommandons d'utiliser l'un des AWS KMS porte-clés dans la mesure du possible. Le SDK AWS Database Encryption 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 adressés à. AWS KMS Pour spécifier un élément AWS KMS key dans un trousseau de clés, utilisez un identifiant de AWS KMS clé pris en charge. Si vous utilisez le trousseau de clés AWS KMS hiérarchique, vous devez spécifier l'ARN de clé. 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 à l'aide d'un AWS KMS trousseau de clés, vous pouvez spécifier n'importe quel identifiant de clé valide (ARN de clé, nom d'alias, ARN d'alias ou ID de clé) pour une clé KMS de chiffrement symétrique. Si vous utilisez une clé RSA KMS asymétrique, vous devez spécifier l'ARN de la clé.

    Si vous spécifiez un nom d'alias ou un alias ARN pour une clé KMS lors du chiffrement, le SDK AWS Database Encryption enregistre l'ARN de clé actuellement associé à cet alias ; il n'enregistre pas l'alias. Les modifications apportées à l'alias n'affectent pas la clé KMS 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 KMS particulières). Vous devez utiliser un ARN clé AWS KMS keys pour vous identifier en vue du déchiffrement.

    Lorsque vous chiffrez à l'aide d'un AWS KMS trousseau de clés, le SDK AWS de chiffrement de base de données stocke l'ARN de la clé AWS KMS key dans la description du matériau avec la clé de données cryptée. Lors du déchiffrement en mode strict, le SDK de chiffrement de AWS base de données vérifie que la même clé ARN apparaît dans le trousseau de clés avant de tenter d'utiliser la clé d'encapsulation pour déchiffrer la clé de données chiffrée. Si vous utilisez un identifiant de clé différent, le SDK AWS de chiffrement de base de données ne le reconnaîtra pas et ne l'utilisera pas 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'encapsulage. Tout d'abord, le SDK AWS Database Encryption 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 SDK de chiffrement AWS de base de données demande AWS KMS à déchiffrer l'enregistrement à l'aide de la clé KMS qui l'a chiffré, quel que soit le propriétaire de cette clé KMS ou y ayant accès.

Pour spécifier une clé AES brute ou une paire de clés RSA brute en tant que clé encapsulée 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 vous avez utilisés lors du chiffrement. Si vous utilisez un espace de noms ou un nom différent, le SDK de chiffrement AWS de base de données ne reconnaîtra pas ou n'utilisera pas la clé encapsulée, même si le matériau de la clé est le même.

Création d'un filtre de découverte

Lorsque vous déchiffrez des données chiffrées avec des clés KMS, il est recommandé de les déchiffrer en mode strict, c'est-à-dire de limiter les clés d'encapsulation utilisées uniquement à celles que vous spécifiez. Toutefois, si nécessaire, vous pouvez également déchiffrer en mode découverte, où vous ne spécifiez aucune clé d'encapsulage. Dans ce mode, AWS KMS vous pouvez déchiffrer la clé de données chiffrée à l'aide de la clé KMS qui l'a chiffrée, quel que soit le propriétaire de cette clé KMS ou y ayant accès.

Si vous devez déchiffrer en mode découverte, nous vous recommandons de toujours utiliser un filtre de découverte, qui limite les clés KMS pouvant être utilisées à celles d'une partition Compte AWS et spécifiée. Le filtre de découverte est facultatif, mais c'est 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 exemples de valeurs 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
};
Rust
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
    .partition("aws")
    .account_ids(111122223333)
    .build()?;

Utilisation de bases de données mutualisées

Le SDK AWS Database Encryption vous permet de configurer le chiffrement côté client pour les bases de données dont le schéma est partagé en isolant chaque locataire à l'aide de 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 que la multilocation peut avoir sur celles-ci. Par exemple, l'utilisation d'une base de données mutualisée peut avoir un impact sur votre capacité à combiner le SDK AWS Database Encryption 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 trousseaux de AWS KMS 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-tenant 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 de clé primaire (par exemple, la clé de partition dans une table Amazon DynamoDB), la gestion de vos clés est plus facile.

Vous pouvez utiliser le AWS KMS trousseau de clés pour isoler chaque locataire avec un AWS KMS porte-clés distinct et. AWS KMS keys En fonction du volume d' AWS KMS appels passés par locataire, vous souhaiterez peut-être 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 matériaux des 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 SDK AWS Database Encryption utilise des balises standard et des balises composées pour fournir des solutions de cryptage consultables qui vous permettent de rechercher des enregistrements chiffrés sans déchiffrer l'intégralité de la base de données interrogée. Cependant, le SDK AWS Database Encryption prend également en charge les balises signées qui peuvent être configurées entièrement à 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 les SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT champs SIGN_ONLY et.

Par exemple, si vous possédez une base de données mutualisée, vous souhaiterez peut-être créer une balise signée qui vous permettra d'interroger votre base de données pour les 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 des balises composées

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 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.

 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

Consultez 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 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.

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 parties signées dans des listes définies localement ou globalement. Nous vous recommandons de définir vos parties signées dans une liste globale dans la version balise chaque fois que possible. En définissant les parties signées globalement, vous pouvez définir chaque pièce une seule fois, puis les réutiliser dans plusieurs configurations de balises composées. Si vous avez l'intention d'utiliser une partie signée une seule fois, vous pouvez la définir dans une liste locale dans la configuration des balises signées. Vous pouvez faire référence à la fois aux pièces locales et globales dans votre liste de constructeurs.

Si vous définissez vos listes de pièces signées de manière globale, vous devez fournir une liste de composants constructeurs qui identifie 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 SDK AWS Database Encryption. Déployez la nouvelle version auprès de tous les lecteurs avant de définir de nouvelles parties à l'échelle mondiale.

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ée ne peut pas être le même que celui d'un champ non chiffré. Deux balises ne peuvent pas avoir le même nom de balise.

Caractère divisé

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

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

Liste des pièces signées

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 SDK AWS Database Encryption utilisera automatiquement le nom comme source. Nous vous 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 vous recommandons d'utiliser une valeur courte qui permet de distinguer la pièce des autres parties desservies par la balise composée.

Nous vous recommandons de définir vos parties signées de manière globale dans la mesure du possible. Vous pouvez envisager de définir une partie signée localement si vous avez l'intention de ne l'utiliser que dans une seule balise composée. Un article défini localement ne peut pas avoir le même préfixe ou le même nom qu'un article défini 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 SDK AWS Database Encryption 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 composants du constructeur qui définit la manière dont la balise signée peut être assemblée. Les parties du constructeur sont jointes dans l'ordre dans lequel elles sont ajoutées à la liste, chaque partie étant séparée par le caractère de division spécifié.

Chaque partie du constructeur nomme 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 signée surField1, et Field1.Field2Field1.Field2.Field3, marquez Field2 et Field3 comme facultatif et créez 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 de pouvoir utiliser l'BEGINS_WITHopérateur dans vos requêtes.

Un constructeur réussit si toutes les parties 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 partie constructeur pour chaque partie signée afin de définir si cette partie est requise ou non.

    Le nom de la pièce du 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 méthode d'assemblage possible de la balise signée à l'aide des éléments du constructeur que vous avez créés à 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 obligatoires 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