Crittografia ricercabile per database multitenant

La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul DynamoDB Encryption Client.

Per implementare la crittografia ricercabile nel database, è necessario utilizzare un portachiavi gerarchico AWS KMS . Il portachiavi AWS KMS gerarchico genera, crittografa e decrittografa le chiavi dati utilizzate per proteggere i record. Crea anche la chiave beacon utilizzata per generare beacon. Quando si utilizza il portachiavi AWS KMS Hierarchical con database multitenant, esistono una chiave branch e una chiave beacon distinte per ogni tenant. Per interrogare i dati crittografati in un database multitenant, è necessario identificare i materiali chiave del beacon utilizzati per generare il beacon su cui si sta interrogando. Per ulteriori informazioni, consulta Utilizzo del portachiavi gerarchico per una crittografia ricercabile.

Quando definisci la versione beacon per un database multitenant, specifica un elenco di tutti i beacon standard che hai configurato, un elenco di tutti i beacon composti che hai configurato, una versione beacon e un. keySource È necessario definire la fonte della chiave beacon come e includere a) un MultiKeyStore tempo di permanenza della cache per la cache della chiave beacon locale e la dimensione massima della cache per la cache locale delle chiavi beacon. keyFieldName

Se hai configurato dei beacon firmati, questi devono essere inclusi nel tuo. compoundBeaconList I beacon firmati sono un tipo di beacon composto che indicizza ed esegue interrogazioni complesse su campi e. SIGN_ONLY SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT

Java

List<BeaconVersion> 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# / .NET

var beaconVersions = new List<BeaconVersion>
{
    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

keyFieldNamedefinisce il nome del campo che memorizza la chiave beacon branch-key-id associata alla chiave beacon utilizzata per generare i beacon per un determinato tenant.

Quando si scrivono nuovi record nel database, la chiave branch-key-id che identifica la chiave beacon utilizzata per generare i beacon per quel record viene memorizzata in questo campo.

Per impostazione predefinita, keyField è un campo concettuale che non è memorizzato in modo esplicito nel database. Il AWS Database Encryption SDK identifica la branch-key-idchiave dei dati crittografati nella descrizione del materiale e memorizza il valore concettuale keyField a cui potete fare riferimento nei beacon composti e nei beacon firmati. Poiché la descrizione del materiale è firmata, la parte concettuale è considerata una parte firmata. keyField

Puoi anche includerlo keyField nelle tue azioni crittografiche come SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT campo SIGN_ONLY or per memorizzare esplicitamente il campo nel tuo database. Se si esegue questa operazione, è necessario includerli manualmente keyField ogni volta che si scrive un record branch-key-id nel database.

Interrogazione dei beacon in un database multi-tenant

Per interrogare un beacon, è necessario includere keyField nella query i materiali chiave del beacon appropriati necessari per ricalcolare il beacon. È necessario specificare la chiave branch-key-id associata alla chiave beacon utilizzata per generare i beacon per un record. Non è possibile specificare il nome descrittivo che identifica il fornitore dell'ID della chiave di filiale di branch-key-id un tenant. Puoi includerli keyField nelle tue domande nei seguenti modi.

Fari composti

Che li memorizziate esplicitamente o meno keyField nei vostri archivi, potete includerli keyField direttamente nei vostri beacon compositi come parte firmata. La parte keyField firmata deve essere obbligatoria.

Ad esempio, se si desidera creare un faro composto da due campi encryptedField e compoundBeaconsignedField, è necessario includerlo anche keyField come parte firmata. Ciò consente di eseguire la seguente interrogazione su. compoundBeacon

compoundBeacon = E_encryptedFieldValue.S_signedFieldValue.K_branch-key-id

Fari firmati

Il AWS Database Encryption SDK utilizza beacon standard e composti per fornire soluzioni di crittografia ricercabili. Questi beacon devono includere almeno un campo crittografato. Tuttavia, AWS Database Encryption SDK supporta anche beacon firmati che possono essere configurati interamente da testo e campi in chiaro. SIGN_ONLY SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT

I beacon firmati possono essere costruiti da un'unica parte. Indipendentemente dal fatto che lo memorizziate esplicitamente keyField nei vostri archivi o meno, potete costruire un beacon firmato da keyField e utilizzarlo per creare query composte che combinano una query sul beacon keyField firmato con una query su uno degli altri beacon. Ad esempio, è possibile eseguire la seguente query.

keyField = K_branch-key-id AND compoundBeacon = E_encryptedFieldValue.S_signedFieldValue

Per informazioni sulla configurazione dei beacon firmati, vedere Creazione di beacon firmati

Effettua una query direttamente su keyField

Se hai specificato il keyField nelle tue azioni crittografiche e lo hai archiviato in modo esplicito nel tuo record, puoi creare una query composta che combina una query sul tuo beacon con una query su. keyField Puoi scegliere di interrogare direttamente su keyField se desideri interrogare un beacon standard. Ad esempio, è possibile eseguire la seguente query.

keyField = branch-key-id AND standardBeacon = S_standardBeaconValue