Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Portachiavi
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
[Il AWS Database Encryption SDK utilizza i *portachiavi* per eseguire la crittografia delle buste.](concepts.md#envelope-encryption) I keyring generano, crittografano e decrittano le chiavi di dati. I portachiavi determinano l'origine delle chiavi dati univoche che proteggono ogni record crittografato e delle chiavi di [avvolgimento che crittografano tale chiave](concepts.md#wrapping-key) di dati. Puoi specificare un keyring durante la crittografia e lo stesso keyring o uno diverso durante la decrittazione.
I keyring possono essere utilizzati singolarmente o combinati in [keyring multipli](use-multi-keyring.md). Anche se la maggior parte dei keyring è in grado di generare, crittografare e decrittare le chiavi di dati, ne puoi creare uno che esegua solo una determinata operazione, ad esempio la generazione delle chiavi di dati, e utilizzarlo in combinazione con altri.
Ti consigliamo di utilizzare un portachiavi che protegga le tue chiavi di wrapping ed esegua operazioni crittografiche all'interno di un limite sicuro, come il AWS KMS portachiavi, che utilizza that never leave () unencrypted. AWS KMS keys [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)AWS KMS Puoi anche scrivere un portachiavi che utilizzi chiavi di avvolgimento archiviate nei moduli di sicurezza hardware (HSMs) o protette da altri servizi di chiavi principali.
Il portachiavi determina le chiavi di avvolgimento che proteggono le chiavi dati e, in ultima analisi, i dati. Utilizzate le chiavi di avvolgimento più sicure e pratiche per il vostro compito. Se possibile, utilizzate chiavi di wrapping protette da un modulo di sicurezza hardware (HSM) o da un'infrastruttura di gestione delle chiavi, come le chiavi KMS in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) o le chiavi di crittografia in. [AWS CloudHSM](https://docs.aws.amazon.com/cloudhsm/latest/userguide/)
AWS Database Encryption SDK offre diversi portachiavi e configurazioni di portachiavi ed è possibile creare portachiavi personalizzati. Puoi anche creare un [portachiavi multiplo che includa uno o più portachiavi](use-multi-keyring.md) dello stesso tipo o di un tipo diverso.
**Topics**
+ [Come funzionano i keyring](#using-keyrings)
+ [AWS KMS portachiavi](use-kms-keyring.md)
+ [AWS KMS Portachiavi gerarchici](use-hierarchical-keyring.md)
+ [AWS KMS Portachiavi ECDH](use-kms-ecdh-keyring.md)
+ [Keyring non elaborati AES](use-raw-aes-keyring.md)
+ [Keyring non elaborato RSA](use-raw-rsa-keyring.md)
+ [Portachiavi ECDH grezzi](use-raw-ecdh-keyring.md)
+ [Keyring multipli](use-multi-keyring.md)
## Come funzionano i keyring
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Quando si crittografa e si firma un campo nel database, il Database Encryption SDK richiede al AWS portachiavi i materiali di crittografia. Il portachiavi restituisce una chiave dati in testo semplice, una copia della chiave dati crittografata da ciascuna delle chiavi di avvolgimento del portachiavi e una chiave MAC associata alla chiave dati. AWS Database Encryption SDK utilizza la chiave di testo semplice per crittografare i dati, quindi rimuove la chiave dati in chiaro dalla memoria il prima possibile. Quindi, AWS Database Encryption SDK aggiunge una [descrizione del materiale](concepts.md#material-description) che include le chiavi dei dati crittografati e altre informazioni, come le istruzioni di crittografia e firma. AWS Database Encryption SDK utilizza la chiave MAC per calcolare i codici di autenticazione dei messaggi basati su hash (HMACs) sulla canonicalizzazione della descrizione del materiale e di tutti i campi contrassegnati con o. `ENCRYPT_AND_SIGN` `SIGN_ONLY`
Quando decifri i dati, puoi utilizzare lo stesso portachiavi che hai usato per crittografare i dati o uno diverso. Per decrittografare i dati, un portachiavi di decrittografia deve avere accesso ad almeno una chiave di avvolgimento nel portachiavi di crittografia.
Il AWS Database Encryption SDK passa le chiavi dei dati crittografati dalla descrizione del materiale al portachiavi e chiede al portachiavi di decrittografarle tutte. Il keyring utilizza le chiavi di wrapping per decrittare una delle chiavi di dati crittografate e restituisce una chiave di dati di testo normale. Il AWS Database Encryption SDK utilizza la chiave dati in testo semplice per decrittografare i dati. Se nessuna delle chiavi di wrapping nel keyring è in grado di decrittare una qualsiasi delle chiavi di dati crittografate, l'operazione di decrittazione non riesce.
Puoi utilizzare un singolo keyring o combinarne più di uno dello stesso tipo o di tipi diversi in un [keyring multiplo](use-multi-keyring.md). Quando si crittografano i dati, il portachiavi multiplo restituisce una copia della chiave dati crittografata da tutte le chiavi di avvolgimento in tutti i portachiavi che comprendono il portachiavi multiplo e una chiave MAC associata alla chiave dati. È possibile decrittografare i dati utilizzando un portachiavi con una qualsiasi delle chiavi di avvolgimento del portachiavi multiplo.
# AWS KMS portachiavi
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Un AWS KMS portachiavi utilizza la crittografia simmetrica o RSA asimmetrica per generare, crittografare e [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)decrittografare le chiavi di dati. AWS Key Management Service (AWS KMS) protegge le chiavi KMS ed esegue operazioni crittografiche entro i confini FIPS. Ti consigliamo di utilizzare un AWS KMS portachiavi o un portachiavi con proprietà di sicurezza simili, quando possibile.
Puoi anche utilizzare una chiave KMS simmetrica multiregionale in un portachiavi. AWS KMS Per ulteriori dettagli ed esempi di utilizzo di più regioni, vedere. AWS KMS keys[Utilizzo di più regioni AWS KMS keys](#config-mrks) *Per informazioni sulle chiavi multiregionali, consulta [Uso delle chiavi multiregionali nella Guida](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) per gli AWS Key Management Service sviluppatori.*
AWS KMS i portachiavi possono includere due tipi di chiavi avvolgenti:
+ **Chiave generatrice: genera una chiave** di dati in testo semplice e la crittografa. Un portachiavi che crittografa i dati deve avere una chiave generatrice.
+ **Chiavi aggiuntive**: crittografa la chiave di dati in testo semplice generata dalla chiave del generatore. AWS KMS I portachiavi possono avere zero o più chiavi aggiuntive.
È necessario disporre di una chiave generatrice per crittografare i record. Quando un AWS KMS portachiavi ha una sola AWS KMS chiave, tale chiave viene utilizzata per generare e crittografare la chiave dati.
Come tutti i portachiavi, i AWS KMS portachiavi possono essere utilizzati indipendentemente o in un [portachiavi multiplo con altri portachiavi](use-multi-keyring.md) dello stesso tipo o di un tipo diverso.
**Topics**
+ [AWS KMS Autorizzazioni richieste per i portachiavi](#kms-keyring-permissions)
+ [Identificazione AWS KMS keys in un portachiavi AWS KMS](#kms-keyring-id)
+ [Creazione di un portachiavi AWS KMS](#kms-keyring-create)
+ [Utilizzo di più regioni AWS KMS keys](#config-mrks)
+ [Utilizzo di un portachiavi Discovery AWS KMS](#kms-keyring-discovery)
+ [Utilizzo di un portachiavi AWS KMS Regional Discovery](#kms-keyring-regional)
## AWS KMS Autorizzazioni richieste per i portachiavi
Il AWS Database Encryption SDK non richiede Account AWS e non dipende da nessuno. Servizio AWS Tuttavia, per utilizzare un AWS KMS portachiavi, sono necessarie le seguenti autorizzazioni Account AWS minime sul AWS KMS keys portachiavi.
+ Per crittografare con un AWS KMS portachiavi, è necessaria l'autorizzazione [kms: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) sulla chiave del generatore. È necessaria l'autorizzazione [KMS:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) su tutte le chiavi aggiuntive nel portachiavi. AWS KMS
+ Per decriptare con un AWS KMS portachiavi, è necessaria l'autorizzazione [KMS:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) su almeno una chiave del portachiavi. AWS KMS
+ [Per crittografare con un portachiavi multiplo composto da portachiavi, è necessaria l'autorizzazione kms: sulla AWS KMS chiave del generatore nel portachiavi del generatore. GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) È necessaria l'autorizzazione [KMS:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) su tutte le altre chiavi in tutti gli altri portachiavi. AWS KMS
+ Per crittografare con un AWS KMS portachiavi RSA asimmetrico, non è necessario [kms: GenerateDataKey o KMS:Encrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) [perché è necessario specificare il materiale della chiave pubblica che si desidera utilizzare per la crittografia](https://docs.aws.amazon.com/kms/latest/APIReference/API_Encrypt.html) quando si crea il portachiavi. Non viene effettuata alcuna chiamata durante la crittografia con questo portachiavi. AWS KMS [Per decrittografare con un portachiavi AWS KMS RSA asimmetrico, è necessaria l'autorizzazione KMS:Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
[https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html](https://docs.aws.amazon.com/kms/latest/developerguide/control-access.html)
## Identificazione AWS KMS keys in un portachiavi AWS KMS
Un AWS KMS portachiavi può includerne uno o più. AWS KMS keys Per specificare un elemento AWS KMS key in un AWS KMS portachiavi, utilizzate un identificatore di AWS KMS chiave supportato. Gli identificatori di chiave che è possibile utilizzare per identificare un elemento AWS KMS key in un portachiavi variano a seconda dell'operazione e dell'implementazione del linguaggio. *Per informazioni dettagliate sugli identificatori chiave di an AWS KMS key, consulta [Key Identifiers](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) nella Developer Guide.AWS Key Management Service *
Come procedura consigliata, utilizzate l'identificatore di chiave più specifico e pratico per la vostra attività.
+ [Per crittografare con un AWS KMS portachiavi, puoi utilizzare un [ID chiave, un ARN di chiave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-id)[, un nome alias o un [alias](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-name) ARN](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN) per crittografare i dati.](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-alias-ARN)
**Nota**
Se si specifica un nome alias o un alias ARN per una chiave KMS in un portachiavi di crittografia, l'operazione di crittografia salva la chiave ARN attualmente associata all'alias nei metadati della chiave dati crittografata. Non salva l'alias. Le modifiche all'alias non influiscono sulla chiave KMS utilizzata per decrittografare le chiavi di dati crittografate.
+ Per decrittografare con un AWS KMS portachiavi, è necessario utilizzare una chiave ARN per l'identificazione. AWS KMS keys Per informazioni dettagliate, vedi [Selezione delle chiavi di avvolgimento](configure.md#config-keys).
+ In un keyring utilizzato per la crittografia e la decrittazione devi utilizzare un ARN di chiave per identificare le AWS KMS keys.
Durante la decrittografia, AWS Database Encryption SDK cerca nel portachiavi una soluzione in AWS KMS key grado di decrittografare una delle AWS KMS chiavi di dati crittografate. In particolare, AWS Database Encryption SDK utilizza lo schema seguente per ogni chiave di dati crittografata nella descrizione del materiale.
+ Il AWS Database Encryption SDK ottiene l'ARN della AWS KMS key chiave che ha crittografato la chiave dati dai metadati della descrizione del materiale.
+ Il AWS Database Encryption SDK cerca nel portachiavi di decrittografia un ARN con AWS KMS key una chiave corrispondente.
+ Se trova un ARN AWS KMS key con una chiave ARN corrispondente nel portachiavi, AWS Database Encryption SDK chiede di utilizzare la chiave KMS per AWS KMS decrittografare la chiave dati crittografata.
+ In caso contrario, passa alla chiave di dati crittografata successiva, se presente.
## Creazione di un portachiavi AWS KMS
È possibile configurare ogni AWS KMS portachiavi con uno AWS KMS key o più portachiavi nello stesso e AWS KMS keys in modo diverso Account AWS . Regioni AWS AWS KMS key Deve essere una chiave di crittografia simmetrica (`SYMMETRIC_DEFAULT`) o una chiave RSA KMS asimmetrica. [È inoltre possibile utilizzare una chiave KMS multiregionale con crittografia simmetrica.](#config-mrks) [È possibile utilizzare uno o più AWS KMS portachiavi in un portachiavi multiplo.](use-multi-keyring.md)
È possibile creare un AWS KMS portachiavi che crittografa e decrittografa i dati oppure creare AWS KMS portachiavi specifici per crittografare o decrittografare. Quando si crea un AWS KMS portachiavi per crittografare i dati, è necessario specificare una *chiave generatrice, AWS KMS key che viene utilizzata per generare una chiave* di dati in testo semplice e crittografarla. La chiave dati non è matematicamente correlata alla chiave KMS. Quindi, se lo desideri, puoi specificarne altre AWS KMS keys che crittografano la stessa chiave di dati in testo normale. Per decrittografare un campo crittografato protetto da questo portachiavi, il portachiavi di decrittografia utilizzato deve includere almeno uno dei valori definiti nel portachiavi, altrimenti no. AWS KMS keys AWS KMS keys[(Un AWS KMS portachiavi senza è noto come portachiavi Discovery. AWS KMS keys )AWS KMS](#kms-keyring-discovery)
Tutte le chiavi di inserimento in un portachiavi crittografico o in un portachiavi multiplo devono essere in grado di crittografare la chiave dati. Se una chiave di wrapping non riesce a crittografare, il metodo di crittografia fallisce. Di conseguenza, il chiamante deve disporre delle [autorizzazioni necessarie](#kms-keyring-permissions) per tutte le chiavi del portachiavi. Se si utilizza un portachiavi Discovery per crittografare i dati, da solo o in un portachiavi multiplo, l'operazione di crittografia non riesce.
Gli esempi seguenti utilizzano il `CreateAwsKmsMrkMultiKeyring` metodo per creare un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo crea automaticamente il AWS KMS client e garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che a più regioni. Questi esempi utilizzano una [chiave ARNs per identificare le chiavi KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id-key-ARN). Per maggiori dettagli, consultare [Identificazione AWS KMS keys in un portachiavi AWS KMS](#kms-keyring-id).
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = kmsKeyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_mrk_multi_keyring()
.generator(kms_key_id)
.send()
.await?;
```
------
Gli esempi seguenti utilizzano il `CreateAwsKmsRsaKeyring` metodo per creare un AWS KMS portachiavi con una chiave RSA KMS asimmetrica. Per creare un portachiavi RSA asimmetrico, fornisci i seguenti valori. AWS KMS
+ `kmsClient`: crea un nuovo client AWS KMS
+ `kmsKeyID`: la chiave ARN che identifica la tua chiave RSA KMS asimmetrica
+ `publicKey`: a ByteBuffer di un file PEM con codifica UTF-8 che rappresenta la chiave pubblica della chiave a cui hai passato `kmsKeyID`
+ `encryptionAlgorithm`: l'algoritmo di crittografia deve essere o `RSAES_OAEP_SHA_256` `RSAES_OAEP_SHA_1`
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsRsaKeyringInput createAwsKmsRsaKeyringInput =
CreateAwsKmsRsaKeyringInput.builder()
.kmsClient(KmsClient.create())
.kmsKeyId(rsaKMSKeyArn)
.publicKey(publicKey)
.encryptionAlgorithm(EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256)
.build();
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsRsaKeyringInput = new CreateAwsKmsRsaKeyringInput
{
KmsClient = new AmazonKeyManagementServiceClient(),
KmsKeyId = rsaKMSKeyArn,
PublicKey = publicKey,
EncryptionAlgorithm = EncryptionAlgorithmSpec.RSAES_OAEP_SHA_256
};
IKeyring awsKmsRsaKeyring = matProv.CreateAwsKmsRsaKeyring(createAwsKmsRsaKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_rsa_keyring = mpl
.create_aws_kms_rsa_keyring()
.kms_key_id(rsa_kms_key_arn)
.public_key(public_key)
.encryption_algorithm(aws_sdk_kms::types::EncryptionAlgorithmSpec::RsaesOaepSha256)
.kms_client(aws_sdk_kms::Client::new(&sdk_config))
.send()
.await?;
```
------
## Utilizzo di più regioni AWS KMS keys
È possibile utilizzare più regioni AWS KMS keys come chiavi di wrapping nel AWS Database Encryption SDK. Se si esegue la crittografia con una chiave multiregionale in una Regione AWS, è possibile decrittografare utilizzando una chiave multiregionale correlata in un'altra. Regione AWS
Le chiavi KMS multiregionali sono un insieme di chiavi diverse Regioni AWS che hanno lo stesso AWS KMS keys materiale chiave e lo stesso ID di chiave. Puoi usare queste chiavi *correlate* come se fossero la stessa chiave in diverse regioni. Le chiavi multiregionali supportano scenari di disaster recovery e backup comuni che richiedono la crittografia in una regione e la decrittografia in un'altra regione senza effettuare una chiamata interregionale a. AWS KMS*Per informazioni sulle chiavi multiregionali, consulta Using Multiregion Keys nella [Developer Guide](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html).AWS Key Management Service *
Per supportare le chiavi multiregionali, il AWS Database Encryption SDK include i portachiavi. AWS KMS multi-Region-aware Il `CreateAwsKmsMrkMultiKeyring` metodo supporta sia chiavi a regione singola che a più regioni.
+ Per le chiavi a regione singola, il multi-Region-aware simbolo si comporta esattamente come il portachiavi a regione singola. AWS KMS Tenta di decrittografare il testo cifrato solo con la chiave a regione singola che ha crittografato i dati. Per semplificare la tua esperienza AWS KMS con il portachiavi, ti consigliamo di utilizzare questo `CreateAwsKmsMrkMultiKeyring` metodo ogni volta che utilizzi una chiave KMS con crittografia simmetrica.
+ Per le chiavi multiregionali, il multi-Region-aware simbolo tenta di decrittografare il testo cifrato con la stessa chiave multiregionale che ha crittografato i dati o con la relativa chiave multiregionale nella regione specificata.
Nei multi-Region-aware portachiavi che utilizzano più di una chiave KMS, puoi specificare più chiavi singole e multiregionali. Tuttavia, puoi specificare solo una chiave per ogni set di chiavi multiregionali correlate. Se specificate più di un identificatore di chiave con lo stesso ID chiave, la chiamata al costruttore ha esito negativo.
Gli esempi seguenti creano un AWS KMS portachiavi con una chiave KMS multiregionale. Gli esempi specificano una chiave multiregionale come chiave del generatore e una chiave a regione singola come chiave secondaria.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput =
CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(multiRegionKeyArn)
.kmsKeyIds(Collections.singletonList(kmsKeyArn))
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = multiRegionKeyArn,
KmsKeyIds = new List { kmsKeyArn }
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(multiRegion_key_arn)
.kms_key_ids(vec![key_arn.to_string()])
.send()
.await?;
```
------
Quando si utilizzano AWS KMS portachiavi multiregione, è possibile decrittografare il testo cifrato in modalità rigorosa o in modalità discovery. Per decrittografare il testo cifrato in modalità rigorosa, istanzia il simbolo multi-Region-aware con la chiave ARN della chiave multiregione correlata nella regione in cui stai decrittografando il testo cifrato. Se si specifica la chiave ARN di una chiave multiregionale correlata in una regione diversa (ad esempio, la regione in cui il record è stato crittografato), il multi-Region-aware simbolo effettuerà una chiamata interregionale a tale scopo. AWS KMS key
Quando si decrittografa in modalità rigorosa, il multi-Region-aware simbolo richiede una chiave ARN. Accetta solo una chiave ARN da ogni set di chiavi multiregione correlate.
È inoltre possibile decrittografare in *modalità di scoperta* con chiavi multiregionali. AWS KMS Durante la decrittografia in modalità di rilevamento, non ne viene specificata alcuna. AWS KMS keys(Per informazioni sui portachiavi Single-Region AWS KMS Discovery, consulta.) [Utilizzo di un portachiavi Discovery AWS KMS](#kms-keyring-discovery)
Se è stata crittografata con una chiave multiregionale, il multi-Region-aware simbolo in modalità di individuazione tenterà di decrittografare utilizzando una chiave multiregionale correlata nella regione locale. Se non ne esiste nessuna, la chiamata ha esito negativo. In modalità di individuazione, AWS Database Encryption SDK non tenterà di effettuare una chiamata interregionale per la chiave multiregionale utilizzata per la crittografia.
## Utilizzo di un portachiavi Discovery AWS KMS
Durante la decrittografia, è consigliabile specificare le chiavi di wrapping che il AWS Database Encryption SDK può utilizzare. Per seguire questa procedura ottimale, utilizza un portachiavi di AWS KMS decrittografia che limiti le chiavi di AWS KMS wrapping a quelle specificate. Tuttavia, puoi anche creare un *portachiavi AWS KMS Discovery, ovvero un AWS KMS portachiavi* che non specifichi alcuna chiave di avvolgimento.
Il AWS Database Encryption SDK fornisce un portachiavi di AWS KMS rilevamento standard e un portachiavi di rilevamento per chiavi multiregionali. AWS KMS Per informazioni sull'utilizzo di chiavi multiregionali con AWS Database Encryption SDK, consulta. [Utilizzo di più regioni AWS KMS keys](#config-mrks)
Poiché non specifica alcuna chiave di wrapping, un portachiavi Discovery non può crittografare i dati. Se si utilizza un portachiavi Discovery per crittografare i dati, da solo o in un portachiavi multiplo, l'operazione di crittografia non riesce.
Durante la decrittografia, un portachiavi Discovery consente al AWS Database Encryption SDK di chiedere AWS KMS di decrittografare qualsiasi chiave di dati crittografata utilizzando quella chiave crittografata, indipendentemente da chi la possiede o ha accesso a AWS KMS key tale chiave. AWS KMS key La chiamata ha esito positivo solo quando il chiamante dispone dell'autorizzazione per. `kms:Decrypt` AWS KMS key
**Importante**
Se includi un portachiavi AWS KMS Discovery in un portachiavi [multiplo di decrittografia, il portachiavi](use-multi-keyring.md) Discovery ha la precedenza su tutte le restrizioni relative alle chiavi KMS specificate dagli altri portachiavi del portachiavi multiplo. Il portachiavi multiplo si comporta come il portachiavi meno restrittivo. Se si utilizza un portachiavi Discovery per crittografare i dati, da solo o in un portachiavi multiplo, l'operazione di crittografia non riesce
Il AWS Database Encryption SDK fornisce un portachiavi di rilevamento per comodità. AWS KMS ma, se possibile, consigliamo di utilizzare un keyring di portata più limitata per i motivi seguenti.
+ **Autenticità**: un portachiavi AWS KMS Discovery può utilizzare qualsiasi AWS KMS key chiave utilizzata per crittografare una chiave di dati nella descrizione del materiale, purché il chiamante sia autorizzato a utilizzarla per la decrittografia. AWS KMS key Questo potrebbe non essere quello AWS KMS key che il chiamante intende utilizzare. Ad esempio, una delle chiavi di dati crittografate potrebbe essere stata crittografata con un metodo meno sicuro AWS KMS key che chiunque può utilizzare.
+ **Latenza e prestazioni**: un portachiavi AWS KMS Discovery potrebbe essere sensibilmente più lento rispetto ad altri portachiavi perché AWS Database Encryption SDK tenta di decrittografare tutte le chiavi di dati crittografate, comprese quelle crittografate AWS KMS keys in altre regioni, Account AWS e AWS KMS keys che il chiamante non è autorizzato a utilizzare per la decrittografia.
Se utilizzi un portachiavi di rilevamento, ti consigliamo di utilizzare un [*filtro di rilevamento*](configure.md#config-discovery) per limitare le chiavi KMS che possono essere utilizzate a quelle presenti in [partizioni Account AWS](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) e specifiche. Per informazioni su come trovare l'ID e la partizione dell'account, consulta [I tuoi Account AWS identificatori e](https://docs.aws.amazon.com/general/latest/gr/acct-identifiers.html) il formato [ARN in. *Riferimenti generali di AWS*](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arns-syntax)
I seguenti esempi di codice creano un'istanza di un portachiavi di AWS KMS rilevamento con un filtro di rilevamento che limita le chiavi KMS che AWS Database Encryption SDK può utilizzare a quelle presenti nella partizione e nell'account di esempio. `aws` `111122223333`
Prima di utilizzare questo codice, sostituisci i valori di esempio Account AWS e di partizione con valori validi per la tua partizione and. Account AWS Se le tue chiavi KMS si trovano nelle regioni della Cina, usa il valore della `aws-cn` partizione. Se le tue chiavi KMS sono inserite AWS GovCloud (US) Regions, usa il valore della `aws-us-gov` partizione. Per tutti gli altri Regioni AWS, usa il valore della `aws` partizione.
------
#### [ Java ]
```
// Create discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.send()
.await?;
```
------
## Utilizzo di un portachiavi AWS KMS Regional Discovery
Un *portachiavi AWS KMS Regional Discovery* è un portachiavi che non specifica le ARNs chiavi KMS. Al contrario, consente al AWS Database Encryption SDK di decrittografare utilizzando solo le chiavi KMS in particolare. Regioni AWS
Quando si esegue la decrittografia con un keyring di rilevamento AWS KMS regionale, AWS Database Encryption SDK decrittografa qualsiasi chiave di dati crittografata che è stata crittografata con un valore specificato. AWS KMS key Regione AWS Per avere successo, il chiamante deve disporre dell'`kms:Decrypt`autorizzazione su almeno una delle chiavi di dati specificate che hanno crittografato una AWS KMS keys chiave dati. Regione AWS
Come altri portachiavi Discovery, il portachiavi Discovery regionale non ha alcun effetto sulla crittografia. Funziona solo quando si decifrano campi crittografati. Se si utilizza un portachiavi Regional Discovery in un portachiavi multiplo utilizzato per la crittografia e la decrittografia, è efficace solo durante la decrittografia. Se si utilizza un portachiavi di rilevamento multiregionale per crittografare i dati, da solo o in un portachiavi multiregionale, l'operazione di crittografia non riesce.
**Importante**
Se includi un portachiavi di rilevamento AWS KMS regionale in un portachiavi multiplo di decrittografia, il portachiavi di rilevamento regionale ha la precedenza su tutte le restrizioni relative alle [chiavi KMS specificate dagli altri portachiavi del portachiavi multiplo](use-multi-keyring.md). Il portachiavi multiplo si comporta come il portachiavi meno restrittivo. Un portachiavi AWS KMS Discovery non ha alcun effetto sulla crittografia se utilizzato da solo o in un portachiavi multiplo.
Il portachiavi di rilevamento regionale nel AWS Database Encryption SDK tenta di decrittografare solo con chiavi KMS nella regione specificata. Quando si utilizza un portachiavi di rilevamento, si configura la regione sul client. AWS KMS Queste implementazioni di AWS Database Encryption SDK non filtrano le chiavi KMS per regione, ma AWS KMS falliranno una richiesta di decrittografia per le chiavi KMS al di fuori della regione specificata.
Se utilizzi un portachiavi di rilevamento, ti consigliamo di utilizzare un *filtro di rilevamento per limitare le chiavi KMS utilizzate nella decrittografia* a quelle presenti nelle partizioni e nelle partizioni specificate. Account AWS
Ad esempio, il codice seguente crea un portachiavi di rilevamento AWS KMS regionale con un filtro di rilevamento. Questo portachiavi limita l'SDK di crittografia del AWS database alle chiavi KMS nell'account 111122223333 nella regione Stati Uniti occidentali (Oregon) (us-west-2).
------
#### [ Java ]
```
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
.partition("aws")
.accountIds(111122223333)
.build();
// Create the discovery keyring
CreateAwsKmsMrkDiscoveryMultiKeyringInput createAwsKmsMrkDiscoveryMultiKeyringInput = CreateAwsKmsMrkDiscoveryMultiKeyringInput.builder()
.discoveryFilter(discoveryFilter)
.regions("us-west-2")
.build();
IKeyring decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create discovery filter
var discoveryFilter = new DiscoveryFilter
{
Partition = "aws",
AccountIds = 111122223333
};
// Create the discovery keyring
var createAwsKmsMrkDiscoveryMultiKeyringInput = new CreateAwsKmsMrkDiscoveryMultiKeyringInput
{
DiscoveryFilter = discoveryFilter,
Regions = us-west-2
};
var decryptKeyring = matProv.CreateAwsKmsMrkDiscoveryMultiKeyring(createAwsKmsMrkDiscoveryMultiKeyringInput);
```
------
#### [ Rust ]
```
// Create discovery filter
let discovery_filter = DiscoveryFilter::builder()
.partition("aws")
.account_ids(111122223333)
.build()?;
// Create the discovery keyring
let decrypt_keyring = mpl
.create_aws_kms_mrk_discovery_multi_keyring()
.discovery_filter(discovery_filter)
.regions(us-west-2)
.send()
.await?;
```
------
# AWS KMS Portachiavi gerarchici
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
**Nota**
A partire dal 24 luglio 2023, le chiavi di filiale create durante l'anteprima per sviluppatori non sono supportate. Crea nuove chiavi branch per continuare a utilizzare l'archivio di chiavi creato durante l'anteprima per sviluppatori.
Con il portachiavi AWS KMS Hierarchical, puoi proteggere i tuoi materiali crittografici con una chiave KMS a crittografia simmetrica senza chiamare AWS KMS ogni volta che crittografi o decrittografi un record. È una buona scelta per le applicazioni che devono ridurre al minimo le chiamate e le applicazioni che possono riutilizzare alcuni materiali crittografici AWS KMS senza violare i requisiti di sicurezza.
Il portachiavi Hierarchical è una soluzione di memorizzazione nella cache dei materiali crittografici che riduce il numero di AWS KMS chiamate utilizzando *chiavi branch AWS KMS * protette persistenti in una tabella Amazon DynamoDB e quindi memorizzando nella cache locale i materiali chiave delle branch utilizzati nelle operazioni di crittografia e decrittografia. La tabella DynamoDB funge da archivio di chiavi che gestisce e protegge le chiavi delle filiali. Memorizza la chiave di ramo attiva e tutte le versioni precedenti della chiave di ramo. La chiave di ramo *attiva* è la versione più recente della chiave di filiale. Il portachiavi Hierarchical utilizza una chiave di crittografia dei dati unica per ogni richiesta di crittografia e crittografa ogni chiave di crittografia dei dati con una chiave di wrapping unica derivata dalla chiave branch attiva. Il portachiavi Hierarchical dipende dalla gerarchia stabilita tra le chiavi branch attive e le relative chiavi di wrapping derivate.
Il portachiavi Hierarchical utilizza in genere ogni versione della chiave branch per soddisfare più richieste. Tuttavia, puoi controllare la misura in cui le chiavi di ramo attive vengono riutilizzate e determinare la frequenza con cui la chiave di ramo attiva viene ruotata. La versione attiva della chiave di ramo rimane attiva finché non viene [ruotata](rotate-branch-key.md). Le versioni precedenti della chiave di ramo attiva non verranno utilizzate per eseguire operazioni di crittografia, ma potranno comunque essere interrogate e utilizzate nelle operazioni di decrittografia.
Quando si crea un'istanza del portachiavi Hierarchical, viene creata una cache locale. Si specifica un [limite di cache](#cache-limit) che definisce la quantità massima di tempo in cui i materiali chiave del branch vengono archiviati nella cache locale prima che scadano e vengano rimossi dalla cache. Il portachiavi Hierarchical effettua una AWS KMS chiamata per decrittografare la chiave del ramo e assemblare i materiali delle chiavi del ramo la prima volta che a viene specificato in un'operazione. `branch-key-id` I materiali delle chiavi di filiale vengono quindi archiviati nella cache locale e riutilizzati per tutte le operazioni di crittografia e decrittografia che lo specificano fino alla scadenza del limite di cache. `branch-key-id` La memorizzazione dei materiali chiave della filiale nella cache locale riduce le chiamate. AWS KMS Ad esempio, si consideri un limite di cache di 15 minuti. Se si eseguono 10.000 operazioni di crittografia entro tale limite di cache, il [AWS KMS portachiavi tradizionale](use-kms-keyring.md) dovrebbe effettuare 10.000 AWS KMS chiamate per soddisfare 10.000 operazioni di crittografia. Se ne hai uno attivo`branch-key-id`, il portachiavi Hierarchical deve effettuare solo una AWS KMS chiamata per soddisfare 10.000 operazioni di crittografia.
La cache locale separa i materiali di crittografia dai materiali di decrittografia. I materiali di crittografia vengono assemblati a partire dalla chiave branch attiva e riutilizzati per tutte le operazioni di crittografia fino alla scadenza del limite della cache. I materiali di decrittografia vengono assemblati a partire dall'ID e dalla versione della chiave di filiale identificati nei metadati del campo crittografato e vengono riutilizzati per tutte le operazioni di decrittografia relative all'ID e alla versione della chiave di filiale fino alla scadenza del limite della cache. La cache locale può memorizzare più versioni della stessa chiave di ramo contemporaneamente. Quando la cache locale è configurata per utilizzare a[branch key ID supplier](#branch-key-id-supplier), può anche archiviare i materiali chiave delle branch provenienti da più chiavi di branch attive contemporaneamente.
**Nota**
Tutte le menzioni del *portachiavi gerarchico nel AWS Database Encryption SDK si riferiscono al portachiavi* gerarchico. AWS KMS
**Topics**
+ [Come funziona](#how-hierarchical-keyring-works)
+ [Prerequisiti](#hierarchical-keyring-prereqs)
+ [Autorizzazioni richieste](#hierarchical-keyring-permissions)
+ [Scegli una cache](#hierarchical-keyring-caches)
+ [Crea un portachiavi gerarchico](#initialize-hierarchical-keyring)
+ [Utilizzo del portachiavi gerarchico per una crittografia ricercabile](#searchable-encryption-hierarchical-keyrings)
## Come funziona
Le seguenti procedure dettagliate descrivono come il portachiavi Hierarchical assembla i materiali di crittografia e decrittografia e le diverse chiamate che il portachiavi effettua per le operazioni di crittografia e decrittografia. [Per i dettagli tecnici sulla derivazione delle chiavi di wrapping e sui processi di crittografia delle chiavi di dati in chiaro, consulta Dettagli tecnici del portachiavi gerarchico.AWS KMS](reference.md#hierarchical-keyring-details)
**Crittografa e firma**
La procedura dettagliata seguente descrive come il portachiavi Hierarchical assembla i materiali di crittografia e ricava una chiave di avvolgimento unica.
1. Il metodo di crittografia richiede al portachiavi Hierarchical i materiali di crittografia. Il portachiavi genera una chiave di dati in testo semplice, quindi verifica se nella cache locale sono presenti materiali chiave branch validi per generare la chiave di wrapping. **Se sono presenti materiali validi per le chiavi di filiale, il portachiavi passa alla Fase 4.**
1. Se non ci sono materiali validi per le chiavi di ramo, il portachiavi Hierarchical interroga l'archivio delle chiavi per la chiave di ramo attiva.
1. Il key store chiama AWS KMS per decrittografare la chiave branch attiva e restituisce la chiave branch attiva in testo semplice. I dati che identificano la chiave di ramo attiva vengono serializzati per fornire dati autenticati aggiuntivi (AAD) nella chiamata di decrittografia a. AWS KMS
1. L'archivio chiavi restituisce la chiave di ramo in testo semplice e i dati che la identificano, ad esempio la versione della chiave di filiale.
1. Il portachiavi Hierarchical assembla i materiali chiave del ramo (la chiave di ramo in testo semplice e la versione della chiave di ramo) e ne archivia una copia nella cache locale.
1. Il portachiavi Hierarchical ricava una chiave di avvolgimento unica dalla chiave branch in testo semplice e un sale casuale a 16 byte. Utilizza la chiave di wrapping derivata per crittografare una copia della chiave di dati in testo non crittografato.
Il metodo di crittografia utilizza i materiali di crittografia per crittografare e firmare il record. Per ulteriori informazioni su come i record vengono crittografati e firmati nel AWS Database Encryption SDK, [consulta Encrypt](how-it-works.md#encrypt-and-sign) and sign.
**Decrittografa e verifica**
La procedura dettagliata seguente descrive come il portachiavi gerarchico assembla i materiali di decrittografia e decrittografa la chiave di dati crittografata.
1. Il metodo di decrittografia identifica la chiave di dati crittografata dal campo di descrizione del materiale del record crittografato e la passa al portachiavi gerarchico.
1. Il portachiavi Hierarchical deserializza i dati che identificano la chiave dati crittografata, inclusa la versione della chiave branch, il sale da 16 byte e altre informazioni che descrivono come è stata crittografata la chiave dati.
Per ulteriori informazioni, consulta [AWS KMS Dettagli tecnici del portachiavi gerarchico](reference.md#hierarchical-keyring-details).
1. **Il portachiavi Hierarchical verifica se nella cache locale sono presenti materiali chiave di filiale validi che corrispondono alla versione della chiave di filiale identificata nel passaggio 2.** **Se sono presenti materiali validi per le chiavi di filiale, il portachiavi passa alla Fase 6.**
1. **Se non ci sono materiali validi per le chiavi di ramo, il portachiavi Hierarchical interroga l'archivio delle chiavi per la chiave di filiale che corrisponde alla versione della chiave di filiale identificata nello Step 2.**
1. L'archivio chiavi chiama AWS KMS per decrittografare la chiave di ramo e restituisce la chiave di ramo attiva in testo semplice. I dati che identificano la chiave di ramo attiva vengono serializzati per fornire dati autenticati aggiuntivi (AAD) nella chiamata di decrittografia a. AWS KMS
1. L'archivio chiavi restituisce la chiave di ramo in testo semplice e i dati che la identificano, ad esempio la versione della chiave di filiale.
1. Il portachiavi Hierarchical assembla i materiali chiave del ramo (la chiave di ramo in testo semplice e la versione della chiave di ramo) e ne archivia una copia nella cache locale.
1. Il portachiavi Hierarchical utilizza i materiali delle chiavi branch assemblate e il sale da 16 byte identificato nella **fase 2** per riprodurre la chiave di avvolgimento univoca che crittografava la chiave dati.
1. Il portachiavi Hierarchical utilizza la chiave di wrapping riprodotta per decrittografare la chiave dati e restituisce la chiave dati in testo semplice.
Il metodo di decrittografia utilizza i materiali di decrittografia e la chiave di dati in testo semplice per decrittografare e verificare il record. [Per ulteriori informazioni su come i record vengono decrittografati e verificati nel Database Encryption SDK, consulta Decriptare e verificare. AWS](how-it-works.md#decrypt-and-verify)
## Prerequisiti
Prima di creare e utilizzare un portachiavi gerarchico, assicurati che siano soddisfatti i seguenti prerequisiti.
+ Tu o il tuo amministratore dell'archivio chiavi avete [creato un archivio chiavi e [creato almeno una](create-branch-keys.md) chiave](create-keystore.md) di ramo attiva.
+ Hai [configurato le azioni del tuo archivio chiavi](keystore-actions.md#config-keystore-actions).
**Nota**
Il modo in cui configuri le azioni del tuo archivio chiavi determina quali operazioni puoi eseguire e quali chiavi KMS possono essere utilizzate dal portachiavi Hierarchical. [Per ulteriori informazioni, consulta Key store actions.](keystore-actions.md)
+ Disponi delle AWS KMS autorizzazioni necessarie per accedere e utilizzare le chiavi del key store e del branch. Per ulteriori informazioni, consulta [Autorizzazioni richieste](#hierarchical-keyring-permissions).
+ Hai esaminato i tipi di cache supportati e configurato il tipo di cache più adatto alle tue esigenze. Per ulteriori informazioni, consulta [Scegli una cache](#hierarchical-keyring-caches)
## Autorizzazioni richieste
Il AWS Database Encryption SDK non richiede Account AWS e non dipende da nessuno Servizio AWS. Tuttavia, per utilizzare un portachiavi gerarchico, sono necessarie le seguenti autorizzazioni Account AWS minime per le AWS KMS key crittografie simmetriche presenti nell'archivio delle chiavi.
+ [Per crittografare e decrittografare i dati con il portachiavi Hierarchical, è necessario KMS:Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
+ [https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html)
Per ulteriori informazioni sul controllo dell'accesso alle chiavi di filiale e all'archivio delle chiavi, consulta. [Implementazione di autorizzazioni con privilegio minimo](keystore-least-privilege.md)
## Scegli una cache
Il portachiavi gerarchico riduce il numero di chiamate effettuate AWS KMS memorizzando localmente nella cache i materiali chiave della filiale utilizzati nelle operazioni di crittografia e decrittografia. Prima di [creare il tuo portachiavi Hierarchical](#initialize-hierarchical-keyring), devi decidere che tipo di cache vuoi usare. È possibile utilizzare la cache predefinita o personalizzarla in base alle proprie esigenze.
Il portachiavi Hierarchical supporta i seguenti tipi di cache:
+ [Cache predefinita](#cache-default)
+ [MultiThreaded cache](#cache-multithreaded)
+ [StormTracking cache](#cache-stormtracking)
+ [Cache condivisa](#cache-shared)
### Cache predefinita
Per la maggior parte degli utenti, la cache predefinita soddisfa i requisiti di threading. La cache predefinita è progettata per supportare ambienti con molti multithread. Quando una voce relativa ai materiali delle chiavi di branch scade, la cache predefinita impedisce la chiamata di più thread AWS KMS notificando a un thread che la voce relativa ai materiali della chiave di branch sta per scadere con 10 secondi di anticipo. Ciò garantisce che solo un thread invii una richiesta di aggiornamento della cache AWS KMS .
Il valore predefinito e le StormTracking cache supportano lo stesso modello di threading, ma è sufficiente specificare la capacità di ingresso per utilizzare la cache predefinita. Per personalizzazioni più granulari della cache, usa. [StormTracking cache](#cache-stormtracking)
A meno che non si desideri personalizzare il numero di voci relative ai materiali chiave del ramo che possono essere archiviate nella cache locale, non è necessario specificare un tipo di cache quando si crea il portachiavi Hierarchical. Se non si specifica un tipo di cache, il portachiavi Hierarchical utilizza il tipo di cache predefinito e imposta la capacità di immissione su 1000.
Per personalizzare la cache predefinita, specificare i seguenti valori:
+ **Capacità di ingresso**: limita il numero di voci relative ai materiali chiave della filiale che possono essere archiviate nella cache locale.
------
#### [ Java ]
```
.cache(CacheType.builder()
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType defaultCache = new CacheType
{
Default = new DefaultCache{EntryCapacity = 100}
};
```
------
#### [ Rust ]
```
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
```
------
### MultiThreaded cache
La MultiThreaded cache è sicura da usare in ambienti multithread, ma non fornisce alcuna funzionalità per ridurre al minimo AWS KMS le chiamate Amazon DynamoDB. Di conseguenza, quando scade l'immissione di materiali chiave in una filiale, tutti i thread verranno avvisati contemporaneamente. Ciò può comportare più AWS KMS chiamate per aggiornare la cache.
Per utilizzare la MultiThreaded cache, specificate i seguenti valori:
+ **Capacità di ingresso**: limita il numero di voci relative ai materiali chiave della filiale che possono essere archiviate nella cache locale.
+ **Entry Poting Tail Size**: definisce il numero di elementi da potare se viene raggiunta la capacità di ingresso.
------
#### [ Java ]
```
.cache(CacheType.builder()
.MultiThreaded(MultiThreadedCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType multithreadedCache = new CacheType
{
MultiThreaded = new MultiThreadedCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1
}
};
```
------
#### [ Rust ]
```
CacheType::MultiThreaded(
MultiThreadedCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.build()?)
```
------
### StormTracking cache
La StormTracking cache è progettata per supportare ambienti con molti multithread. Quando una voce relativa ai materiali della chiave di filiale scade, la StormTracking cache impedisce la chiamata di più thread AWS KMS notificando in anticipo a un thread che la voce relativa ai materiali chiave della branch sta per scadere. Ciò garantisce che solo un thread invii una richiesta di aggiornamento della cache AWS KMS .
Per utilizzare la StormTracking cache, specificate i seguenti valori:
+ **Capacità di ingresso**: limita il numero di voci relative ai materiali chiave della filiale che possono essere archiviate nella cache locale.
Valore predefinito: 1000 voci
+ **Dimensione della coda di potatura** di base: definisce il numero di materiali chiave del ramo da potare alla volta.
Valore predefinito: 1 voce
+ **Periodo di tolleranza**: definisce il numero di secondi prima della scadenza in cui viene effettuato un tentativo di aggiornare i materiali chiave della filiale.
Valore predefinito: 10 secondi
+ **Intervallo di grazia**: definisce il numero di secondi tra i tentativi di aggiornamento dei materiali chiave del ramo.
Valore predefinito: 1 secondi
+ **Fan out**: definisce il numero di tentativi simultanei che è possibile effettuare per aggiornare i materiali chiave della filiale.
Valore predefinito: 20 tentativi
+ **In flight time to live (TTL)**: definisce il numero di secondi che mancano al timeout di un tentativo di aggiornamento dei materiali chiave della filiale. Ogni volta che la cache ritorna `NoSuchEntry` in risposta a una`GetCacheEntry`, quella chiave di ramo viene considerata *in esecuzione finché la* stessa chiave non viene scritta con una `PutCache` voce.
Valore predefinito: 10 secondi
+ **Sospensione**: definisce il numero di secondi in cui un thread deve essere sospeso se `fanOut` viene superato il limite.
Valore predefinito: 20 millisecondi
------
#### [ Java ]
```
.cache(CacheType.builder()
.StormTracking(StormTrackingCache.builder()
.entryCapacity(100)
.entryPruningTailSize(1)
.gracePeriod(10)
.graceInterval(1)
.fanOut(20)
.inFlightTTL(10)
.sleepMilli(20)
.build())
```
------
#### [ C\$1 / .NET ]
```
CacheType stormTrackingCache = new CacheType
{
StormTracking = new StormTrackingCache
{
EntryCapacity = 100,
EntryPruningTailSize = 1,
FanOut = 20,
GraceInterval = 1,
GracePeriod = 10,
InFlightTTL = 10,
SleepMilli = 20
}
};
```
------
#### [ Rust ]
```
CacheType::StormTracking(
StormTrackingCache::builder()
.entry_capacity(100)
.entry_pruning_tail_size(1)
.grace_period(10)
.grace_interval(1)
.fan_out(20)
.in_flight_ttl(10)
.sleep_milli(20)
.build()?)
```
------
### Cache condivisa
Per impostazione predefinita, il portachiavi Hierarchical crea una nuova cache locale ogni volta che si crea un'istanza del portachiavi. Tuttavia, la cache condivisa può aiutare a risparmiare memoria consentendoti di condividere una cache tra più portachiavi gerarchici. Anziché creare una nuova cache di materiali crittografici per ogni portachiavi gerarchico istanziato, la cache condivisa archivia solo una cache in memoria, che può essere utilizzata da tutti i portachiavi gerarchici che vi fanno riferimento. La cache condivisa aiuta a ottimizzare l'utilizzo della memoria evitando la duplicazione di materiali crittografici tra portachiavi. I portachiavi gerarchici possono invece accedere alla stessa cache sottostante, riducendo l'ingombro complessivo della memoria.
Quando crei la cache condivisa, definisci comunque il tipo di cache. È possibile specificare un [Cache predefinita](#cache-default)[MultiThreaded cache](#cache-multithreaded), o [StormTracking cache](#cache-stormtracking) come tipo di cache o sostituire qualsiasi cache personalizzata compatibile.
**Partizioni**
Più portachiavi gerarchici possono utilizzare un'unica cache condivisa. **Quando si crea un portachiavi gerarchico con una cache condivisa, è possibile definire un ID di partizione opzionale.** L'ID di partizione distingue quale portachiavi gerarchico sta scrivendo nella cache. Se due portachiavi gerarchici fanno riferimento allo stesso ID di partizione e allo stesso ID di chiave di filiale[logical key store name](create-keystore.md#logical-key-store-name), i due portachiavi condivideranno le stesse voci della cache. Se si creano due portachiavi gerarchici con la stessa cache condivisa, ma una partizione diversa IDs, ogni portachiavi accederà alle voci della cache solo dalla propria partizione designata all'interno della cache condivisa. Le partizioni agiscono come divisioni logiche all'interno della cache condivisa, consentendo a ciascun portachiavi gerarchico di funzionare indipendentemente sulla propria partizione designata, senza interferire con i dati memorizzati nell'altra partizione.
Se si intende riutilizzare o condividere le voci della cache in una partizione, è necessario definire il proprio ID di partizione. Quando passate l'ID della partizione al portachiavi Hierarchical, il portachiavi può riutilizzare le voci della cache che sono già presenti nella cache condivisa, anziché dover recuperare e autorizzare nuovamente i materiali delle chiavi della branch. Se non si specifica un ID di partizione, un ID di partizione univoco viene assegnato automaticamente al portachiavi ogni volta che si crea un'istanza del portachiavi Hierarchical.
Le seguenti procedure mostrano come creare una cache condivisa con il [tipo di cache predefinito](#cache-default) e passarla a un portachiavi gerarchico.
1. Crea un `CryptographicMaterialsCache` (CMC) utilizzando la [Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL).
------
#### [ Java ]
```
// Instantiate the MPL
final MaterialProviders matProv =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
// Create a CacheType object for the Default cache
final CacheType cache =
CacheType.builder()
.Default(DefaultCache.builder().entryCapacity(100).build())
.build();
// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
CreateCryptographicMaterialsCacheInput.builder()
.cache(cache)
.build();
final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ C\$1 / .NET ]
```
// Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };
// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};
var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
```
------
#### [ Rust ]
```
// Instantiate the MPL
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create a CacheType object for the default cache
let cache: CacheType = CacheType::Default(
DefaultCache::builder()
.entry_capacity(100)
.build()?,
);
// Create a CMC using the default cache
let shared_cryptographic_materials_cache: CryptographicMaterialsCacheRef = mpl.
create_cryptographic_materials_cache()
.cache(cache)
.send()
.await?;
```
------
1. Crea un `CacheType` oggetto per la cache condivisa.
Passa `sharedCryptographicMaterialsCache` il file creato nel **passaggio 1** al nuovo `CacheType` oggetto.
------
#### [ Java ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
CacheType.builder()
.Shared(sharedCryptographicMaterialsCache)
.build();
```
------
#### [ C\$1 / .NET ]
```
// Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
```
------
#### [ Rust ]
```
// Create a CacheType object for the shared_cryptographic_materials_cache
let shared_cache: CacheType = CacheType::Shared(shared_cryptographic_materials_cache);
```
------
1. Passa l'`sharedCache`oggetto dallo **Step 2** al tuo portachiavi gerarchico.
Quando crei un portachiavi gerarchico con una cache condivisa, puoi facoltativamente definire un portachiavi gerarchico `partitionID` per condividere le voci della cache su più portachiavi gerarchici. Se non si specifica un ID di partizione, il portachiavi Hierarchical assegna automaticamente al portachiavi un ID di partizione univoco.
**Nota**
I portachiavi gerarchici condivideranno le stesse voci della cache in una cache condivisa se crei due o più portachiavi che fanno riferimento allo stesso ID di partizione e allo stesso ID di chiave di filiale. [logical key store name](create-keystore.md#logical-key-store-name) Se non desideri che più portachiavi condividano le stesse voci della cache, devi utilizzare un ID di partizione univoco per ogni portachiavi gerarchico.
[L'esempio seguente crea un portachiavi Hierarchical con un [branch key ID supplier](#branch-key-id-supplier) limite di cache di 600 secondi.](#cache-limit) Per ulteriori informazioni sui valori definiti nella seguente configurazione del portachiavi gerarchico, vedere. [Crea un portachiavi gerarchico](#initialize-hierarchical-keyring)
------
#### [ Java ]
```
// Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(sharedCache)
.partitionID(partitionID)
.build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
// Create the Hierarchical keyring
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
Cache = sharedCache,
TtlSeconds = 600,
PartitionId = partitionID
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
```
------
#### [ Rust ]
```
// Create the Hierarchical keyring
let keyring1 = mpl
.create_aws_kms_hierarchical_keyring()
.key_store(key_store1)
.branch_key_id(branch_key_id.clone())
// CryptographicMaterialsCacheRef is an Rc (Reference Counted), so if you clone it to
// pass it to different Hierarchical Keyrings, it will still point to the same
// underlying cache, and increment the reference count accordingly.
.cache(shared_cache.clone())
.ttl_seconds(600)
.partition_id(partition_id.clone())
.send()
.await?;
```
------
## Crea un portachiavi gerarchico
Per creare un portachiavi gerarchico, è necessario fornire i seguenti valori:
+ **Il nome di un archivio di chiavi**
Il nome della tabella DynamoDB che tu o il tuo amministratore del key store avete creato per fungere da archivio chiavi.
+
**Un limite di durata della cache (TTL)**
La quantità di tempo, in secondi, durante la quale una chiave di filiale deve essere inserita nella cache locale può essere utilizzata prima della scadenza. Il limite di cache TTL determina la frequenza con cui il client chiama AWS KMS per autorizzare l'uso delle chiavi della filiale. Questo valore deve essere maggiore di zero. Dopo la scadenza del limite di cache TTL, la voce non viene mai fornita e verrà rimossa dalla cache locale.
+ **Un identificatore di chiave di filiale**
Puoi configurare staticamente il codice `branch-key-id` che identifica una singola chiave di filiale attiva nel tuo archivio di chiavi o fornire un fornitore di ID per le chiavi di filiale.
Il *fornitore di ID della chiave di filiale* utilizza i campi memorizzati nel contesto di crittografia per determinare quale chiave di filiale è necessaria per decrittografare un record. Per impostazione predefinita, nel contesto di crittografia sono incluse solo le chiavi di partizione e ordinamento. Tuttavia, è possibile utilizzare l'[azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica](concepts.md#crypt-actions) per includere campi aggiuntivi nel contesto di crittografia.
Consigliamo vivamente di utilizzare un fornitore di ID di chiavi di filiale per database multitenant in cui ogni tenant ha la propria chiave di filiale. Puoi utilizzare il fornitore di ID delle chiavi di filiale per creare un nome descrittivo per la tua chiave IDs di filiale in modo da facilitare il riconoscimento dell'ID corretto della chiave di filiale per un tenant specifico. Ad esempio, il nome descrittivo consente di fare riferimento a una chiave di filiale come `tenant1` invece di`b3f61619-4d35-48ad-a275-050f87e15122`.
Per le operazioni di decrittografia, è possibile configurare staticamente un singolo portachiavi gerarchico per limitare la decrittografia a un singolo tenant, oppure è possibile utilizzare il fornitore di ID della chiave di filiale per identificare quale tenant è responsabile della decrittografia di un record.
+ **(Facoltativo) Una cache**
Se desideri personalizzare il tipo di cache o il numero di voci relative ai materiali chiave della filiale che possono essere archiviate nella cache locale, specifica il tipo di cache e la capacità di accesso quando inizializzi il portachiavi.
Il portachiavi Hierarchical supporta i seguenti tipi di cache: predefinita, MultiThreaded e condivisa. StormTracking Per ulteriori informazioni ed esempi che dimostrano come definire ogni tipo di cache, vedere. [Scegli una cache](#hierarchical-keyring-caches)
Se non si specifica una cache, il portachiavi gerarchico utilizza automaticamente il tipo di cache predefinito e imposta la capacità di ingresso su 1000.
+ **(Facoltativo) Un ID di partizione**
Se si specifica il[Cache condivisa](#cache-shared), è possibile definire facoltativamente un ID di partizione. L'ID di partizione distingue quale portachiavi Hierarchical sta scrivendo nella cache. Se si intende riutilizzare o condividere le voci della cache in una partizione, è necessario definire il proprio ID di partizione. È possibile specificare qualsiasi stringa per l'ID della partizione. Se non si specifica un ID di partizione, al portachiavi viene assegnato automaticamente un ID di partizione univoco al momento della creazione.
Per ulteriori informazioni, consulta [Partitions](#shared-cache-partitions).
**Nota**
I portachiavi gerarchici condivideranno le stesse voci della cache in una cache condivisa se crei due o più portachiavi che fanno riferimento allo stesso ID di partizione e allo stesso ID di chiave di filiale. [logical key store name](create-keystore.md#logical-key-store-name) Se non desideri che più portachiavi condividano le stesse voci della cache, devi utilizzare un ID di partizione univoco per ogni portachiavi gerarchico.
+ **(Facoltativo) Un elenco di token di concessione**
Se controlli l'accesso alla chiave KMS nel tuo portachiavi gerarchico con le [concessioni, devi fornire tutti i](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) token di concessione necessari quando inizializzi il portachiavi.
### Crea un portachiavi gerarchico con un ID di chiave branch statico
Gli esempi seguenti mostrano come creare un portachiavi gerarchico con un ID di chiave branch statico[Cache predefinita](#cache-default), the e un limite di cache TTL di 600 secondi.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyId(branch-key-id)
.ttlSeconds(600)
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(branch_key_store_name)
.ttl_seconds(600)
.send()
.await?;
```
------
### Crea un portachiavi gerarchico con una chiave di filiale (ID fornitore).
Le seguenti procedure mostrano come creare un portachiavi gerarchico con un fornitore di ID di chiave di filiale.
1. Crea un fornitore di ID chiave di filiale
L'esempio seguente crea nomi descrittivi per le due chiavi di ramo create nel **passaggio 1** e chiama `CreateDynamoDbEncryptionBranchKeyIdSupplier` a creare un fornitore di ID di chiavi di filiale con il client AWS Database Encryption SDK per DynamoDB.
------
#### [ Java ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
private static String branchKeyIdForTenant1;
private static String branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this.branchKeyIdForTenant1 = tenant1Id;
this.branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
.DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
.build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
.ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2))
.build()).branchKeyIdSupplier();
```
------
#### [ C\$1 / .NET ]
```
// Create friendly names for each branch-key-id
class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
private String _branchKeyIdForTenant1;
private String _branchKeyIdForTenant2;
public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
this._branchKeyIdForTenant1 = tenant1Id;
this._branchKeyIdForTenant2 = tenant2Id;
}
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
{
DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2)
}).BranchKeyIdSupplier;
```
------
#### [ Rust ]
```
// Create friendly names for each branch_key_id
pub struct ExampleBranchKeyIdSupplier {
branch_key_id_for_tenant1: String,
branch_key_id_for_tenant2: String,
}
impl ExampleBranchKeyIdSupplier {
pub fn new(tenant1_id: &str, tenant2_id: &str) -> Self {
Self {
branch_key_id_for_tenant1: tenant1_id.to_string(),
branch_key_id_for_tenant2: tenant2_id.to_string(),
}
}
}
// Create the branch key ID supplier
let dbesdk_config = DynamoDbEncryptionConfig::builder().build()?;
let dbesdk = dbesdk_client::Client::from_conf(dbesdk_config)?;
let supplier = ExampleBranchKeyIdSupplier::new(tenant1_branch_key_id, tenant2_branch_key_id);
let branch_key_id_supplier = dbesdk
.create_dynamo_db_encryption_branch_key_id_supplier()
.ddb_key_branch_key_id_supplier(supplier)
.send()
.await?
.branch_key_id_supplier
.unwrap();
```
------
1. Crea un portachiavi gerarchico
I seguenti esempi inizializzano un portachiavi gerarchico con il branch key ID supplier creato nel **passaggio 1**, un TLL limite di cache di 600 secondi e una dimensione massima della cache di 1000.
------
#### [ Java ]
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(keystore)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(100)
.build())
.build())
.build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 100 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let hierarchical_keyring = mpl
.create_aws_kms_hierarchical_keyring()
.branch_key_id_supplier(branch_key_id_supplier)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
------
## Utilizzo del portachiavi gerarchico per una crittografia ricercabile
[La crittografia ricercabile](searchable-encryption.md) consente di cercare record crittografati senza decrittografare l'intero database. [Ciò si ottiene indicizzando il valore in chiaro di un campo crittografato con un beacon.](beacons.md) Per implementare la crittografia ricercabile, è necessario utilizzare un portachiavi gerarchico.
*L'`CreateKey`operazione di archiviazione delle chiavi genera sia una chiave branch che una chiave beacon.* La chiave branch viene utilizzata nelle operazioni di crittografia e decrittografia dei record. La chiave beacon viene utilizzata per generare beacon.
La chiave branch e la chiave beacon sono protette dallo stesso AWS KMS key che hai specificato durante la creazione del servizio di archiviazione delle chiavi. Dopo che l'`CreateKey`operazione chiama AWS KMS per generare la chiave branch, chiama [kms: GenerateDataKeyWithoutPlaintext](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKeyWithoutPlaintext.html) una seconda volta per generare la chiave beacon utilizzando la seguente richiesta.
```
{
"EncryptionContext": {
"branch-key-id" : "branch-key-id",
"type" : type,
"create-time" : "timestamp",
"tablename" : "the logical table name for your key store",
"kms-arn" : the KMS key ARN,
"hierarchy-version" : 1
},
"KeyId": "the KMS key ARN",
"NumberOfBytes": "32"
}
```
Dopo aver generato entrambe le chiavi, l'`CreateKey`operazione chiama [ddb: TransactWriteItems](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_TransactWriteItems.html) per scrivere due nuovi elementi che mantengano la chiave branch e la chiave beacon nell'archivio delle chiavi della filiale.
Quando [configuri un beacon standard](configure-beacons.md#config-standard-beacons), AWS Database Encryption SDK interroga l'archivio delle chiavi per la chiave beacon. [Quindi, utilizza una funzione di derivazione delle extract-and-expand chiavi basata su HMAC ([HKDF](https://en.wikipedia.org/wiki/HKDF)) per combinare la chiave beacon con il nome del beacon standard per creare la chiave HMAC per un determinato beacon.](beacons.md#standard-beacon-overview)
A differenza delle chiavi branch, esiste una sola versione di chiave beacon per ogni chiave. `branch-key-id` La chiave beacon non viene mai ruotata.
### Definizione della fonte della chiave del beacon
Quando si definisce la [versione beacon](using-beacons.md#beacon-version) per i beacon standard e compositi, è necessario identificare la chiave beacon e definire un TTL (cache limit time to live) per i materiali chiave del beacon. I materiali delle chiavi beacon vengono archiviati in una cache locale separata dalle chiavi branch. Il seguente frammento mostra come definire un database single-tenant. `keySource` Identifica la tua chiave beacon in base alla quale è associata. `branch-key-id`
------
#### [ Java ]
```
keySource(BeaconKeySource.builder()
.single(SingleKeyStore.builder()
.keyId(branch-key-id)
.cacheTTL(6000)
.build())
.build())
```
------
#### [ C\$1 / .NET ]
```
KeySource = new BeaconKeySource
{
Single = new SingleKeyStore
{
KeyId = branch-key-id,
CacheTTL = 6000
}
}
```
------
#### [ Rust ]
```
.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()?,
))
```
------
**Definizione della fonte del beacon in un database multitenant**
Se si dispone di un database multitenant, è necessario specificare i seguenti valori durante la configurazione di. `keySource`
+
**keyFieldName**
Definisce 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. `keyFieldName`Può essere una stringa qualsiasi, ma deve essere univoca per tutti gli altri campi del database. 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. È necessario includere questo campo nelle query del beacon e identificare i materiali chiave del beacon appropriati necessari per ricalcolare il beacon. Per ulteriori informazioni, consulta [Interrogazione dei beacon in un database multi-tenant](searchable-encryption-multitenant.md#query-multitenant-beacons).
+ **CacheTTL**
La quantità di tempo, in secondi, necessaria per l'immissione di una chiave beacon nella cache locale del beacon prima della scadenza. Questo valore deve essere maggiore di zero. Quando il limite di cache TTL scade, la voce viene rimossa dalla cache locale.
+ **(Facoltativo) Una cache**
Se desideri personalizzare il tipo di cache o il numero di voci relative ai materiali chiave della filiale che possono essere archiviate nella cache locale, specifica il tipo di cache e la capacità di accesso quando inizializzi il portachiavi.
Il portachiavi Hierarchical supporta i seguenti tipi di cache: predefinita, MultiThreaded e condivisa. StormTracking Per ulteriori informazioni ed esempi che dimostrano come definire ogni tipo di cache, vedere. [Scegli una cache](#hierarchical-keyring-caches)
Se non si specifica una cache, il portachiavi gerarchico utilizza automaticamente il tipo di cache predefinito e imposta la capacità di ingresso su 1000.
L'esempio seguente crea un portachiavi gerarchico con una chiave di filiale (ID provider), un limite di cache (TLL) di 600 secondi e una capacità di immissione di 1000.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
.keyStore(branchKeyStoreName)
.branchKeyIdSupplier(branchKeyIdSupplier)
.ttlSeconds(600)
.cache(CacheType.builder() //OPTIONAL
.Default(DefaultCache.builder()
.entryCapacity(1000)
.build())
.build());
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
KeyStore = keystore,
BranchKeyIdSupplier = branchKeyIdSupplier,
TtlSeconds = 600,
Cache = new CacheType
{
Default = new DefaultCache { EntryCapacity = 1000 }
}
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
```
```
let provider_config = MaterialProvidersConfig::builder().build()?;
let mat_prov = client::Client::from_conf(provider_config)?;
let kms_keyring = mat_prov
.create_aws_kms_hierarchical_keyring()
.branch_key_id(branch_key_id)
.key_store(key_store)
.ttl_seconds(600)
.send()
.await?;
```
# AWS KMS Portachiavi ECDH
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
**Importante**
Il portachiavi AWS KMS ECDH è disponibile solo con la versione 1.5.0 o successiva della Material Providers Library.
Un portachiavi AWS KMS ECDH utilizza un accordo di chiave asimmetrico per ricavare una chiave di avvolgimento simmetrica [AWS KMS keys](https://docs.aws.amazon.com/kms/latest/developerguide/key-types.html)condivisa tra due parti. Innanzitutto, il portachiavi utilizza l'algoritmo di accordo delle chiavi Elliptic Curve Diffie-Hellman (ECDH) per ricavare un segreto condiviso dalla chiave privata nella coppia di chiavi KMS del mittente e dalla chiave pubblica del destinatario. Quindi, il portachiavi utilizza il segreto condiviso per derivare la chiave di wrapping condivisa che protegge le chiavi di crittografia dei dati. [La funzione di derivazione delle chiavi utilizzata da AWS Database Encryption SDK (`KDF_CTR_HMAC_SHA384`) per derivare la chiave di wrapping condivisa è conforme alle raccomandazioni del NIST per la derivazione delle chiavi.](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf)
La funzione di derivazione delle chiavi restituisce 64 byte di materiale di codifica. Per garantire che entrambe le parti utilizzino il materiale di codifica corretto, AWS Database Encryption SDK utilizza i primi 32 byte come chiave di commit e gli ultimi 32 byte come chiave di wrapping condivisa. In caso di decrittografia, se il portachiavi non è in grado di riprodurre la stessa chiave di impegno e la stessa chiave di wrapping condivisa memorizzate nel campo di descrizione del materiale del record crittografato, l'operazione ha esito negativo. Ad esempio, se si crittografa un record con un portachiavi configurato con la chiave privata **di Alice** e la chiave pubblica **di Bob**, un portachiavi configurato con la chiave privata **di Bob** e la chiave pubblica **di Alice** riprodurrà la stessa chiave di impegno e la stessa chiave di wrapping condivisa e sarà in grado di decrittografare il record. Se la chiave pubblica di Bob non proviene da una coppia di chiavi KMS, Bob può creare un [portachiavi ECDH Raw](use-raw-ecdh-keyring.md) per decrittografare il record.
Il portachiavi AWS KMS ECDH crittografa i record con una chiave simmetrica utilizzando AES-GCM. La chiave dati viene quindi crittografata in busta con la chiave di wrapping condivisa derivata utilizzando AES-GCM. [Ogni portachiavi AWS KMS ECDH può avere solo una chiave di avvolgimento condivisa, ma è possibile includere più portachiavi AWS KMS ECDH, da soli o con altri portachiavi, in un portachiavi multiplo.](use-multi-keyring.md)
**Topics**
+ [AWS KMS Autorizzazioni richieste per i portachiavi ECDH](#kms-ecdh-permissions)
+ [AWS KMS Creazione di un portachiavi ECDH](#kms-ecdh-create)
+ [Creazione di un portachiavi ECDH Discovery AWS KMS](#kms-ecdh-discovery)
## AWS KMS Autorizzazioni richieste per i portachiavi ECDH
Il AWS Database Encryption SDK non richiede un AWS account e non dipende da alcun servizio. AWS Tuttavia, per utilizzare un portachiavi AWS KMS ECDH, è necessario disporre di un AWS account e delle seguenti autorizzazioni minime presenti nel portachiavi. AWS KMS keys Le autorizzazioni variano in base allo schema di accordi chiave utilizzato.
+ Per crittografare e decrittografare i record utilizzando lo schema di accordo `KmsPrivateKeyToStaticPublicKey` chiave, sono necessari [kms: GetPublicKey e kms: DeriveSharedSecret](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) [sulla coppia di chiavi KMS asimmetrica](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) del *mittente*. Se fornisci direttamente la chiave pubblica con codifica DER del mittente quando crei un'istanza del tuo portachiavi, hai solo bisogno dell'DeriveSharedSecretautorizzazione [kms: sulla coppia di chiavi KMS asimmetrica](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) del mittente.
+ Per decrittografare i record utilizzando lo schema di accordo `KmsPublicKeyDiscovery` chiave, sono necessarie le GetPublicKey autorizzazioni [kms: DeriveSharedSecret e kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) [sulla coppia di chiavi KMS](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) asimmetrica specificata.
## AWS KMS Creazione di un portachiavi ECDH
Per creare un portachiavi AWS KMS ECDH che crittografa e decrittografa i dati, è necessario utilizzare lo schema degli accordi chiave. `KmsPrivateKeyToStaticPublicKey` Per inizializzare un portachiavi AWS KMS ECDH con lo schema degli accordi chiave, fornisci i seguenti valori: `KmsPrivateKeyToStaticPublicKey`
+ **ID del mittente AWS KMS key **
Deve identificare una coppia di chiavi KMS a curva ellittica (ECC) asimmetrica consigliata dal NIST con un valore di. `KeyUsage` `KEY_AGREEMENT` La chiave privata del mittente viene utilizzata per derivare il segreto condiviso.
+ **(Facoltativo) Chiave pubblica del mittente**
[Deve essere una chiave pubblica X.509 con codifica DER, nota anche come `SubjectPublicKeyInfo` (SPKI), come definita in RFC 5280.](https://tools.ietf.org/html/rfc5280)
L' AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)operazione restituisce la chiave pubblica di una coppia di chiavi KMS asimmetrica nel formato codificato DER richiesto.
Per ridurre il numero di AWS KMS chiamate effettuate dal portachiavi, puoi fornire direttamente la chiave pubblica del mittente. Se non viene fornito alcun valore per la chiave pubblica del mittente, il portachiavi chiama AWS KMS per recuperare la chiave pubblica del mittente.
+ **Chiave pubblica del destinatario**
[È necessario fornire la chiave pubblica X.509 con codifica DER del destinatario, nota anche come `SubjectPublicKeyInfo` (SPKI), come definita in RFC 5280.](https://tools.ietf.org/html/rfc5280)
L' AWS KMS [GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html)operazione restituisce la chiave pubblica di una coppia di chiavi KMS asimmetrica nel formato codificato DER richiesto.
+ **Specificazione della curva**
Identifica la specifica della curva ellittica nelle coppie di chiavi specificate. Entrambe le coppie di chiavi del mittente e del destinatario devono avere la stessa specifica di curva.
Valori validi: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Facoltativo) Un elenco di token di concessione**
Se controlli l'accesso alla chiave KMS nel tuo portachiavi AWS KMS ECDH con le [sovvenzioni](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html), devi fornire tutti i token di concessione necessari quando inizializzi il portachiavi.
------
#### [ C\$1 / .NET ]
L'esempio seguente crea un portachiavi AWS KMS ECDH con la chiave KMS del mittente, la chiave pubblica del mittente e la chiave pubblica del destinatario. Questo esempio utilizza il `senderPublicKey` parametro opzionale per fornire la chiave pubblica del mittente. Se non fornisci la chiave pubblica del mittente, il portachiavi chiama AWS KMS per recuperare la chiave pubblica del mittente. Entrambe le coppie di chiavi del mittente e del destinatario sono pronte. `ECC_NIST_P256`
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Must be DER-encoded X.509 public keys
var BobPublicKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the AWS KMS ECDH static keyring
var staticConfiguration = new KmsEcdhStaticConfigurations
{
KmsPrivateKeyToStaticPublicKey = new KmsPrivateKeyToStaticPublicKeyInput
{
SenderKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
SenderPublicKey = BobPublicKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'esempio seguente crea un portachiavi AWS KMS ECDH con la chiave KMS del mittente, la chiave pubblica del mittente e la chiave pubblica del destinatario. Questo esempio utilizza il `senderPublicKey` parametro opzionale per fornire la chiave pubblica del mittente. Se non fornisci la chiave pubblica del mittente, il portachiavi chiama AWS KMS per recuperare la chiave pubblica del mittente. Entrambe le coppie di chiavi del mittente e del destinatario sono pronte. `ECC_NIST_P256`
```
// Retrieve public keys
// Must be DER-encoded X.509 public keys
ByteBuffer BobPublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab");
ByteBuffer AlicePublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the AWS KMS ECDH static keyring
final CreateAwsKmsEcdhKeyringInput senderKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput.builder()
.senderKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
.senderPublicKey(BobPublicKey)
.recipientPublicKey(AlicePublicKey)
.build()).build()).build();
```
------
#### [ Rust ]
L'esempio seguente crea un portachiavi AWS KMS ECDH con la chiave KMS del mittente, la chiave pubblica del mittente e la chiave pubblica del destinatario. Questo esempio utilizza il `sender_public_key` parametro opzionale per fornire la chiave pubblica del mittente. Se non fornisci la chiave pubblica del mittente, il portachiavi chiama AWS KMS per recuperare la chiave pubblica del mittente.
```
// Retrieve public keys
// Must be DER-encoded X.509 keys
let public_key_file_content_sender = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_SENDER))?;
let parsed_public_key_file_content_sender = parse(public_key_file_content_sender)?;
let public_key_sender_utf8_bytes = parsed_public_key_file_content_sender.contents();
let public_key_file_content_recipient = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content_recipient = parse(public_key_file_content_recipient)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content_recipient.contents();
// Create KmsPrivateKeyToStaticPublicKeyInput
let kms_ecdh_static_configuration_input =
KmsPrivateKeyToStaticPublicKeyInput::builder()
.sender_kms_identifier(arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab)
// Must be a UTF8 DER-encoded X.509 public key
.sender_public_key(public_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let kms_ecdh_static_configuration = KmsEcdhStaticConfigurations::KmsPrivateKeyToStaticPublicKey(kms_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH keyring
let kms_ecdh_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client)
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_static_configuration)
.send()
.await?;
```
------
## Creazione di un portachiavi ECDH Discovery AWS KMS
Durante la decrittografia, è consigliabile specificare le chiavi che il AWS Database Encryption SDK può utilizzare. Per seguire questa best practice, utilizzate un portachiavi AWS KMS ECDH con lo schema degli accordi chiave. `KmsPrivateKeyToStaticPublicKey` Tuttavia, puoi anche creare un portachiavi AWS KMS ECDH discovery, ovvero un portachiavi AWS KMS ECDH in grado di decrittografare qualsiasi record in cui la chiave pubblica della coppia di chiavi KMS specificata corrisponda alla chiave pubblica del *destinatario memorizzata nel campo di descrizione del materiale del* record crittografato.
**Importante**
Quando si decifrano i record utilizzando lo schema degli accordi `KmsPublicKeyDiscovery` chiave, si accettano tutte le chiavi pubbliche, indipendentemente dal proprietario.
Per inizializzare un portachiavi AWS KMS ECDH con lo schema degli accordi `KmsPublicKeyDiscovery` chiave, fornite i seguenti valori:
+ **ID del destinatario AWS KMS key **
Deve identificare una coppia di chiavi KMS a curva ellittica (ECC) asimmetrica consigliata dal NIST con un valore di. `KeyUsage` `KEY_AGREEMENT`
+ **Specificazione della curva**
Identifica la specifica della curva ellittica nella coppia di chiavi KMS del destinatario.
Valori validi: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
+ **(Facoltativo) Un elenco di token di concessione**
Se controlli l'accesso alla chiave KMS nel tuo portachiavi AWS KMS ECDH con le [sovvenzioni](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html), devi fornire tutti i token di concessione necessari quando inizializzi il portachiavi.
------
#### [ C\$1 / .NET ]
L'esempio seguente crea un portachiavi AWS KMS ECDH discovery con una coppia di chiavi KMS sulla curva. `ECC_NIST_P256` È necessario disporre delle DeriveSharedSecret autorizzazioni [kms: GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) e [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) sulla coppia di key pair KMS specificata. Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della coppia di chiavi KMS specificata corrisponde alla chiave pubblica del destinatario memorizzata nel campo di descrizione del materiale del record crittografato.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create the AWS KMS ECDH discovery keyring
var discoveryConfiguration = new KmsEcdhStaticConfigurations
{
KmsPublicKeyDiscovery = new KmsPublicKeyDiscoveryInput
{
RecipientKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'esempio seguente crea un portachiavi AWS KMS ECDH discovery con una coppia di chiavi KMS sulla curva. `ECC_NIST_P256` È necessario disporre delle DeriveSharedSecret autorizzazioni [kms: GetPublicKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GetPublicKey.html) e [kms:](https://docs.aws.amazon.com/kms/latest/APIReference/API_DeriveSharedSecret.html) sulla coppia di key pair KMS specificata. Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della coppia di chiavi KMS specificata corrisponde alla chiave pubblica del destinatario memorizzata nel campo di descrizione del materiale del record crittografato.
```
// Create the AWS KMS ECDH discovery keyring
final CreateAwsKmsEcdhKeyringInput recipientKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput.builder()
.recipientKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321").build()
).build())
.build();
```
------
#### [ Rust ]
```
// Create KmsPublicKeyDiscoveryInput
let kms_ecdh_discovery_static_configuration_input =
KmsPublicKeyDiscoveryInput::builder()
.recipient_kms_identifier(ecc_recipient_key_arn)
.build()?;
let kms_ecdh_discovery_static_configuration = KmsEcdhStaticConfigurations::KmsPublicKeyDiscovery(kms_ecdh_discovery_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH discovery keyring
let kms_ecdh_discovery_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client.clone())
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_discovery_static_configuration)
.send()
.await?;
```
------
# Keyring non elaborati AES
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Il AWS Database Encryption SDK consente di utilizzare una chiave simmetrica AES fornita come chiave di wrapping per proteggere la chiave dati. È necessario generare, archiviare e proteggere il materiale chiave, preferibilmente in un modulo di sicurezza hardware (HSM) o in un sistema di gestione delle chiavi. Usa un portachiavi Raw AES quando devi fornire la chiave di wrapping e crittografare le chiavi dati localmente o offline.
Il portachiavi Raw AES crittografa i dati utilizzando l'algoritmo AES-GCM e una chiave di wrapping specificata come array di byte. [È possibile specificare solo una chiave di avvolgimento in ogni portachiavi Raw AES, ma è possibile includere più portachiavi Raw AES, da soli o con altri portachiavi, in un portachiavi multiplo.](use-multi-keyring.md)
**Namespace e nomi chiave**
*Per identificare la chiave AES in un portachiavi, il portachiavi Raw AES utilizza uno *spazio dei nomi e un nome chiave forniti* dall'utente.* Questi valori non sono segreti. Appaiono in testo semplice nella [descrizione del materiale](concepts.md#material-description) che AWS Database Encryption SDK aggiunge al record. Si consiglia di utilizzare uno spazio dei nomi delle chiavi (HSM o sistema di gestione delle chiavi) e un nome di chiave che identifichi la chiave AES in quel sistema.
**Nota**
*Lo spazio dei nomi e il nome della chiave sono equivalenti ai campi *Provider ID (o *Provider**) e Key ID di.* `JceMasterKey`
Se si creano portachiavi diversi per crittografare e decrittografare un determinato campo, lo spazio dei nomi e i valori dei nomi sono fondamentali. Se lo spazio dei nomi della chiave e il nome della chiave nel portachiavi di decrittografia non corrispondono esattamente, con distinzione tra maiuscole e minuscole, per lo spazio dei nomi della chiave e il nome della chiave nel portachiavi di crittografia, il portachiavi di decrittografia non viene utilizzato, anche se i byte del materiale della chiave sono identici.
Ad esempio, è possibile definire un portachiavi Raw AES con lo spazio dei nomi e il nome della chiave. `HSM_01` `AES_256_012` Quindi, usi quel portachiavi per crittografare alcuni dati. Per decrittografare quei dati, crea un portachiavi Raw AES con lo stesso spazio dei nomi delle chiavi, nome chiave e materiale chiave.
I seguenti esempi mostrano come creare un portachiavi Raw AES. La `AESWrappingKey` variabile rappresenta il materiale chiave fornito.
------
#### [ Java ]
```
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
// This example uses the key generator in Bouncy Castle to generate the key material.
// In production, use key material from a secure source.
var aesWrappingKey = new MemoryStream(GeneratorUtilities.GetKeyGenerator("AES256").GenerateKey());
// Create the keyring
var keyringInput = new CreateRawAesKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var matProv = new MaterialProviders(new MaterialProvidersConfig());
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
```
------
# Keyring non elaborato RSA
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Il portachiavi Raw RSA esegue la crittografia e la decrittografia asimmetriche delle chiavi di dati nella memoria locale con una chiave pubblica e privata RSA fornita dall'utente. È necessario generare, archiviare e proteggere la chiave privata, preferibilmente in un modulo di sicurezza hardware (HSM) o in un sistema di gestione delle chiavi. La funzione di crittografia consente di crittografare la chiave di dati nella chiave pubblica RSA. La funzione di decrittazione consente di decrittare la chiave di dati con la chiave privata. Puoi scegliere tra i diverse modalità di padding RSA.
Un keyring non elaborato RSA che esegue crittografia e decrittazione deve includere una coppia di chiavi pubblica e privata asimmetriche. Tuttavia, è possibile crittografare i dati con un portachiavi Raw RSA che ha solo una chiave pubblica e decrittografare i dati con un portachiavi Raw RSA che ha solo una chiave privata. [Puoi includere qualsiasi portachiavi Raw RSA in un portachiavi multiplo.](use-multi-keyring.md) Se configuri un portachiavi Raw RSA con una chiave pubblica e una privata, assicurati che facciano parte della stessa coppia di chiavi.
Il portachiavi Raw RSA è equivalente e interagisce con il [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)in SDK di crittografia AWS per Java quando viene utilizzato con chiavi di crittografia asimmetrica RSA.
**Nota**
Il portachiavi Raw RSA non supporta le chiavi KMS asimmetriche. [Per utilizzare chiavi RSA KMS asimmetriche, crea un portachiavi.AWS KMS](use-kms-keyring.md)
**Namespace e nomi**
*Per identificare il materiale chiave RSA in un portachiavi, il portachiavi Raw RSA utilizza uno spazio dei nomi e un *nome chiave* forniti dall'utente.* Questi valori non sono segreti. Appaiono in testo semplice nella [descrizione del materiale](concepts.md#material-description) che AWS Database Encryption SDK aggiunge al record. Ti consigliamo di utilizzare lo spazio dei nomi e il nome della chiave che identificano la coppia di chiavi RSA (o la relativa chiave privata) nel tuo HSM o sistema di gestione delle chiavi.
**Nota**
*Lo spazio dei nomi e il nome della chiave sono equivalenti ai campi *Provider ID (o *Provider*) e Key ID* di.* `JceMasterKey`
Se si creano portachiavi diversi per crittografare e decrittografare un determinato record, lo spazio dei nomi e i valori dei nomi sono fondamentali. Se lo spazio dei nomi della chiave e il nome della chiave nel portachiavi di decrittografia non corrispondono esattamente, con distinzione tra maiuscole e minuscole, per lo spazio dei nomi della chiave e il nome della chiave nel portachiavi di crittografia, il portachiavi di decrittografia non viene utilizzato, anche se le chiavi appartengono alla stessa coppia di chiavi.
Lo spazio dei nomi e il nome chiave del materiale chiave nei portachiavi di crittografia e decrittografia devono essere gli stessi indipendentemente dal fatto che il portachiavi contenga la chiave pubblica RSA, la chiave privata RSA o entrambe le chiavi della coppia di chiavi. Ad esempio, supponiamo di crittografare i dati con un portachiavi RSA Raw per una chiave pubblica RSA con spazio dei nomi e nome della chiave. `HSM_01` `RSA_2048_06` Per decrittografare quei dati, costruisci un portachiavi Raw RSA con la chiave privata (o coppia di chiavi) e lo stesso namespace e nome della chiave.
**Modalità di imbottitura**
È necessario specificare una modalità di riempimento per i portachiavi Raw RSA utilizzati per la crittografia e la decrittografia oppure utilizzare funzionalità dell'implementazione del linguaggio che la specificano automaticamente.
AWS Encryption SDK Supporta le seguenti modalità di riempimento, soggette ai vincoli di ogni lingua. Consigliamo una modalità di riempimento [OAEP, in particolare OAEP](https://tools.ietf.org/html/rfc8017#section-7.1) con SHA-256 e con imbottitura SHA-256. MGF1 La modalità padding è supportata solo per la compatibilità con le versioni precedenti. [PKCS1](https://tools.ietf.org/html/rfc8017#section-7.2)
+ OAEP con SHA-1 e con imbottitura SHA-1 MGF1
+ OAEP con SHA-256 e con imbottitura SHA-256 MGF1
+ OAEP con SHA-384 e con imbottitura SHA-384 MGF1
+ OAEP con SHA-512 e MGF1 con imbottitura SHA-512
+ PKCS1 Imbottitura v1.5
Il seguente esempio Java mostra come creare un portachiavi Raw RSA con la chiave pubblica e privata di una coppia di chiavi RSA e l'OAEP con SHA-256 e con modalità padding SHA-256. MGF1 Le variabili and rappresentano il materiale chiave fornito. `RSAPublicKey` `RSAPrivateKey`
------
#### [ Java ]
```
final CreateRawRsaKeyringInput keyringInput = CreateRawRsaKeyringInput.builder()
.keyName("RSA_2048_06")
.keyNamespace("HSM_01")
.paddingScheme(PaddingScheme.OAEP_SHA256_MGF1)
.publicKey(RSAPublicKey)
.privateKey(RSAPrivateKey)
.build();
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
IKeyring rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ C\$1 / .NET ]
```
var keyNamespace = "HSM_01";
var keyName = "RSA_2048_06";
// Get public and private keys from PEM files
var publicKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePublicKey.pem"));
var privateKey = new MemoryStream(System.IO.File.ReadAllBytes("RSAKeyringExamplePrivateKey.pem"));
// Create the keyring input
var keyringInput = new CreateRawRsaKeyringInput
{
KeyNamespace = keyNamespace,
KeyName = keyName,
PaddingScheme = PaddingScheme.OAEP_SHA512_MGF1,
PublicKey = publicKey,
PrivateKey = privateKey
};
// Create the keyring
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var rawRsaKeyring = matProv.CreateRawRsaKeyring(keyringInput);
```
------
#### [ Rust ]
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_rsa_keyring = mpl
.create_raw_rsa_keyring()
.key_name("RSA_2048_06")
.key_namespace("HSM_01")
.padding_scheme(PaddingScheme::OaepSha256Mgf1)
.public_key(RSA_public_key)
.private_key(RSA_private_key)
.send()
.await?;
```
------
# Portachiavi ECDH grezzi
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
**Importante**
Il portachiavi Raw ECDH è disponibile solo con la versione 1.5.0 della Material Providers Library.
Il portachiavi Raw ECDH utilizza le coppie di chiavi pubblica-privata a curva ellittica fornite dall'utente per ricavare una chiave di wrapping condivisa tra due parti. Innanzitutto, il portachiavi ricava un segreto condiviso utilizzando la chiave privata del mittente, la chiave pubblica del destinatario e l'algoritmo di accordo delle chiavi Elliptic Curve Diffie-Hellman (ECDH). Quindi, il portachiavi utilizza il segreto condiviso per derivare la chiave di avvolgimento condivisa che protegge le chiavi di crittografia dei dati. [La funzione di derivazione delle chiavi utilizzata da AWS Database Encryption SDK (`KDF_CTR_HMAC_SHA384`) per derivare la chiave di wrapping condivisa è conforme alle raccomandazioni del NIST per la derivazione delle chiavi.](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf)
La funzione di derivazione delle chiavi restituisce 64 byte di materiale di codifica. Per garantire che entrambe le parti utilizzino il materiale di codifica corretto, AWS Database Encryption SDK utilizza i primi 32 byte come chiave di commit e gli ultimi 32 byte come chiave di wrapping condivisa. In caso di decrittografia, se il portachiavi non è in grado di riprodurre la stessa chiave di impegno e la stessa chiave di wrapping condivisa memorizzate nel campo di descrizione del materiale del record crittografato, l'operazione ha esito negativo. Ad esempio, se si crittografa un record con un portachiavi configurato con la chiave privata **di Alice** e la chiave pubblica **di Bob**, un portachiavi configurato con la chiave privata **di Bob** e la chiave pubblica **di Alice** riprodurrà la stessa chiave di impegno e la stessa chiave di wrapping condivisa e sarà in grado di decrittografare il record. [Se la chiave pubblica di Bob proviene da una AWS KMS key coppia, allora Bob può creare un AWS KMS portachiavi ECDH per decrittografare il record.](use-kms-ecdh-keyring.md)
Il portachiavi Raw ECDH crittografa i record con una chiave simmetrica utilizzando AES-GCM. La chiave dati viene quindi crittografata in busta con la chiave di wrapping condivisa derivata utilizzando AES-GCM. [Ogni portachiavi Raw ECDH può avere solo una chiave di avvolgimento condivisa, ma è possibile includere più portachiavi Raw ECDH, da soli o con altri portachiavi, in un portachiavi multiplo.](use-multi-keyring.md)
L'utente è responsabile della generazione, dell'archiviazione e della protezione delle chiavi private, preferibilmente in un modulo di sicurezza hardware (HSM) o in un sistema di gestione delle chiavi. Le coppie di chiavi del mittente e del destinatario devono trovarsi sulla stessa curva ellittica. Il AWS Database Encryption SDK supporta le seguenti specifiche della curva ellittica:
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`
## Creazione di un portachiavi ECDH non elaborato
Il portachiavi Raw ECDH supporta tre schemi di accordi chiave:, e. `RawPrivateKeyToStaticPublicKey` `EphemeralPrivateKeyToStaticPublicKey` `PublicKeyDiscovery` Lo schema di accordo chiave selezionato determina le operazioni crittografiche che è possibile eseguire e il modo in cui vengono assemblati i materiali di codifica.
**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)
### RawPrivateKeyToStaticPublicKey
Utilizza lo schema degli accordi `RawPrivateKeyToStaticPublicKey` chiave per configurare staticamente la chiave privata del mittente e la chiave pubblica del destinatario nel portachiavi. Questo schema di accordo chiave può crittografare e decrittografare i record.
Per inizializzare un portachiavi Raw ECDH con lo schema degli accordi `RawPrivateKeyToStaticPublicKey` chiave, fornite i seguenti valori:
+ **Chiave privata del mittente**
[È necessario fornire la chiave privata con codifica PEM del mittente ( PrivateKeyInfo strutture PKCS \$18), come definita in RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Chiave pubblica del destinatario**
[È necessario fornire la chiave pubblica X.509 con codifica DER del destinatario, nota anche come `SubjectPublicKeyInfo` (SPKI), come definita in RFC 5280.](https://tools.ietf.org/html/rfc5280)
È possibile specificare la chiave pubblica di una coppia di chiavi KMS con accordo di chiave asimmetrico o la chiave pubblica da una coppia di chiavi generata all'esterno di. AWS
+ **Specificazione della curva**
Identifica la specifica della curva ellittica nelle coppie di chiavi specificate. Entrambe le coppie di chiavi del mittente e del destinatario devono avere la stessa specifica di curva.
Valori validi: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var BobPrivateKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH static keyring
var staticConfiguration = new RawEcdhStaticConfigurations()
{
RawPrivateKeyToStaticPublicKey = new RawPrivateKeyToStaticPublicKeyInput
{
SenderStaticPrivateKey = BobPrivateKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
Il seguente esempio di Java utilizza lo schema di accordo delle `RawPrivateKeyToStaticPublicKey` chiavi per configurare staticamente la chiave privata del mittente e la chiave pubblica del destinatario. Entrambe le coppie di chiavi sono sulla `ECC_NIST_P256` curva.
```
private static void StaticRawKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair senderKeys = GetRawEccKey();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH static keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.RawPrivateKeyToStaticPublicKey(
RawPrivateKeyToStaticPublicKeyInput.builder()
// Must be a PEM-encoded private key
.senderStaticPrivateKey(ByteBuffer.wrap(senderKeys.getPrivate().getEncoded()))
// Must be a DER-encoded X.509 public key
.recipientPublicKey(ByteBuffer.wrap(recipient.getPublic().getEncoded()))
.build()
)
.build()
).build();
final IKeyring staticKeyring = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
Il seguente esempio di Python utilizza lo schema di accordo delle `raw_ecdh_static_configuration` chiavi per configurare staticamente la chiave privata del mittente e la chiave pubblica del destinatario. Entrambe le coppie di chiavi devono trovarsi sulla stessa curva.
```
// Create keyring input
let raw_ecdh_static_configuration_input =
RawPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 PEM-encoded private key
.sender_static_private_key(private_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let raw_ecdh_static_configuration = RawEcdhStaticConfigurations::RawPrivateKeyToStaticPublicKey(raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH static keyring
let raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(raw_ecdh_static_configuration)
.send()
.await?;
```
------
### EphemeralPrivateKeyToStaticPublicKey
I portachiavi configurati con lo schema `EphemeralPrivateKeyToStaticPublicKey` key agreement creano una nuova coppia di chiavi localmente e derivano una chiave di wrapping condivisa unica per ogni chiamata crittografata.
Questo schema di accordo chiave può solo crittografare i record. Per decrittografare i record crittografati con lo schema del contratto di `EphemeralPrivateKeyToStaticPublicKey` chiave, è necessario utilizzare uno schema di accordo di chiave di rilevamento configurato con la chiave pubblica dello stesso destinatario. Per decrittografare, è possibile utilizzare un portachiavi ECDH non elaborato con l'algoritmo di accordo [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)chiave oppure, se la chiave pubblica del destinatario proviene da una coppia di chiavi KMS con accordo di chiave asimmetrico, è possibile AWS KMS utilizzare un portachiavi ECDH con lo schema di accordo chiave. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery)
Per inizializzare un portachiavi ECDH non elaborato con lo schema di accordo chiave, fornisci i seguenti valori: `EphemeralPrivateKeyToStaticPublicKey`
+ **Chiave pubblica del destinatario**
[È necessario fornire la chiave pubblica X.509 con codifica DER del destinatario, nota anche come `SubjectPublicKeyInfo` (SPKI), come definita in RFC 5280.](https://tools.ietf.org/html/rfc5280)
È possibile specificare la chiave pubblica di una coppia di chiavi KMS con accordo di chiave asimmetrico o la chiave pubblica da una coppia di chiavi generata all'esterno di. AWS
+ **Specificazione della curva**
Identifica la specifica della curva ellittica nella chiave pubblica specificata.
In encrypt, il portachiavi crea una nuova coppia di chiavi sulla curva specificata e utilizza la nuova chiave privata e la chiave pubblica specificata per derivare una chiave di wrapping condivisa.
Valori validi: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'esempio seguente crea un portachiavi ECDH non elaborato con lo schema di accordo delle chiavi. `EphemeralPrivateKeyToStaticPublicKey` Su encrypt, il portachiavi creerà una nuova coppia di chiavi localmente sulla curva specificata`ECC_NIST_P256`.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH ephemeral keyring
var ephemeralConfiguration = new RawEcdhStaticConfigurations()
{
EphemeralPrivateKeyToStaticPublicKey = new EphemeralPrivateKeyToStaticPublicKeyInput
{
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = ephemeralConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'esempio seguente crea un portachiavi Raw ECDH con lo schema di accordo chiave. `EphemeralPrivateKeyToStaticPublicKey` Su encrypt, il portachiavi creerà una nuova coppia di chiavi localmente sulla curva specificata`ECC_NIST_P256`.
```
private static void EphemeralRawEcdhKeyring() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
ByteBuffer recipientPublicKey = getPublicKeyBytes();
// Create the Raw ECDH ephemeral keyring
final CreateRawEcdhKeyringInput ephemeralInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.EphemeralPrivateKeyToStaticPublicKey(
EphemeralPrivateKeyToStaticPublicKeyInput.builder()
.recipientPublicKey(recipientPublicKey)
.build()
)
.build()
).build();
final IKeyring ephemeralKeyring = materialProviders.CreateRawEcdhKeyring(ephemeralInput);
}
```
------
#### [ Rust ]
L'esempio seguente crea un portachiavi Raw ECDH con lo schema di accordo chiave. `ephemeral_raw_ecdh_static_configuration` Su encrypt, il portachiavi creerà una nuova coppia di chiavi localmente sulla curva specificata.
```
// Create EphemeralPrivateKeyToStaticPublicKeyInput
let ephemeral_raw_ecdh_static_configuration_input =
EphemeralPrivateKeyToStaticPublicKeyInput::builder()
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let ephemeral_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::EphemeralPrivateKeyToStaticPublicKey(ephemeral_raw_ecdh_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create raw ECDH ephemeral private key keyring
let ephemeral_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(ephemeral_raw_ecdh_static_configuration)
.send()
.await?;
```
------
### PublicKeyDiscovery
Durante la decrittografia, è consigliabile specificare le chiavi di wrapping che il AWS Database Encryption SDK può utilizzare. Per seguire questa best practice, utilizzate un portachiavi ECDH che specifichi sia la chiave privata del mittente che la chiave pubblica del destinatario. Tuttavia, puoi anche creare un portachiavi Raw ECDH Discovery, ovvero un portachiavi ECDH non elaborato in grado di decrittografare qualsiasi record in cui la chiave pubblica della chiave specificata corrisponda alla chiave pubblica del destinatario memorizzata nel campo di descrizione del materiale del record crittografato. Questo schema di accordi chiave può solo decrittografare i record.
**Importante**
Quando si decrittografano i record utilizzando lo schema del contratto di `PublicKeyDiscovery` chiave, si accettano tutte le chiavi pubbliche, indipendentemente dal proprietario.
Per inizializzare un portachiavi Raw ECDH con lo schema di accordo `PublicKeyDiscovery` chiave, fornite i seguenti valori:
+ **Chiave privata statica del destinatario**
[È necessario fornire la chiave privata con codifica PEM del destinatario ( PrivateKeyInfo strutture PKCS \$18), come definita in RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Specificazione della curva**
Identifica la specifica della curva ellittica nella chiave privata specificata. Entrambe le coppie di chiavi del mittente e del destinatario devono avere la stessa specifica di curva.
Valori validi: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'esempio seguente crea un portachiavi Raw ECDH con lo schema di accordo chiave. `PublicKeyDiscovery` Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della chiave privata specificata corrisponda alla chiave pubblica del destinatario memorizzata nel campo di descrizione del materiale del record crittografato.
```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
var AlicePrivateKey = new MemoryStream(new byte[] { });
// Create the Raw ECDH discovery keyring
var discoveryConfiguration = new RawEcdhStaticConfigurations()
{
PublicKeyDiscovery = new PublicKeyDiscoveryInput
{
RecipientStaticPrivateKey = AlicePrivateKey
}
};
var createKeyringInput = new CreateRawEcdhKeyringInput()
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```
------
#### [ Java ]
L'esempio seguente crea un portachiavi ECDH non elaborato con lo schema di accordo delle chiavi. `PublicKeyDiscovery` Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della chiave privata specificata corrisponda alla chiave pubblica del destinatario memorizzata nel campo di descrizione del materiale del record crittografato.
```
private static void RawEcdhDiscovery() {
// Instantiate material providers
final MaterialProviders materialProviders =
MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
KeyPair recipient = GetRawEccKey();
// Create the Raw ECDH discovery keyring
final CreateRawEcdhKeyringInput rawKeyringInput =
CreateRawEcdhKeyringInput.builder()
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
RawEcdhStaticConfigurations.builder()
.PublicKeyDiscovery(
PublicKeyDiscoveryInput.builder()
// Must be a PEM-encoded private key
.recipientStaticPrivateKey(ByteBuffer.wrap(sender.getPrivate().getEncoded()))
.build()
)
.build()
).build();
final IKeyring publicKeyDiscovery = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```
------
#### [ Rust ]
L'esempio seguente crea un portachiavi ECDH non elaborato con lo schema di accordo delle chiavi. `discovery_raw_ecdh_static_configuration` Questo portachiavi può decrittografare qualsiasi messaggio in cui la chiave pubblica della chiave privata specificata corrisponda alla chiave pubblica del destinatario memorizzata nel testo cifrato del messaggio.
```
// Create PublicKeyDiscoveryInput
let discovery_raw_ecdh_static_configuration_input =
PublicKeyDiscoveryInput::builder()
// Must be a UTF8 PEM-encoded private key
.recipient_static_private_key(private_key_recipient_utf8_bytes)
.build()?;
let discovery_raw_ecdh_static_configuration =
RawEcdhStaticConfigurations::PublicKeyDiscovery(discovery_raw_ecdh_static_configuration_input);
// Create raw ECDH discovery private key keyring
let discovery_raw_ecdh_keyring = mpl
.create_raw_ecdh_keyring()
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(discovery_raw_ecdh_static_configuration)
.send()
.await?;
```
------
# Keyring multipli
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
È possibile combinare più keyring in un keyring multiplo. Un *keyring multiplo* è composto da uno o più keyring dello stesso tipo o di tipi diversi. Il risultato è analogo a quello ottenuto utilizzando diversi keyring in serie. Quando utilizzi un keyring multiplo per crittografare i dati, questi possono essere decrittati con le chiavi di wrapping contenute in qualsiasi keyring.
Quando crei un keyring multiplo per crittografare i dati, uno dei keyring viene designato come *keyring generatore*, tutti gli altri keyring sono i *keyring figlio*. che si occupa di generare e crittografare la chiave di dati di testo normale. Quindi, tutte le chiavi di wrapping in tutti i keyring figlio crittografano la stessa chiave di dati di testo normale. Il keyring multiplo restituisce la chiave di dati di testo normale e una chiave di dati crittografata per ciascuna chiave di wrapping nel keyring multiplo. Se il portachiavi del generatore è un portachiavi [KMS, la chiave](use-kms-keyring.md) del generatore nel AWS KMS portachiavi genera e crittografa la chiave in testo semplice. Quindi, tutte le chiavi aggiuntive AWS KMS keys presenti nel portachiavi e tutte le AWS KMS chiavi inserite in tutti i portachiavi secondari del portachiavi multiplo crittografano la stessa chiave in chiaro.
Durante la decrittografia, AWS Database Encryption SDK utilizza i portachiavi per cercare di decrittografare una delle chiavi di dati crittografate. I keyring sono chiamati nell'ordine in cui sono specificati nel keyring multiplo. L'elaborazione si interrompe non appena una chiave in qualsiasi keyring può decrittare una chiave di dati crittografata.
Per creare un keyring multiplo, crea prima un'istanza dei keyring figlio. In questo esempio, utilizziamo un AWS KMS portachiavi e un portachiavi Raw AES, ma puoi combinare tutti i portachiavi supportati in un portachiavi multiplo.
------
#### [ Java ]
```
// 1. Create the raw AES keyring.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateRawAesKeyringInput createRawAesKeyringInput = CreateRawAesKeyringInput.builder()
.keyName("AES_256_012")
.keyNamespace("HSM_01")
.wrappingKey(AESWrappingKey)
.wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
.build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
final CreateAwsKmsMrkMultiKeyringInput createAwsKmsMrkMultiKeyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyArn)
.build();
IKeyring awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
```
// 1. Create the raw AES keyring.
var keyNamespace = "HSM_01";
var keyName = "AES_256_012";
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var createRawAesKeyringInput = new CreateRawAesKeyringInput
{
KeyName = "keyName",
KeyNamespace = "myNamespaces",
WrappingKey = AESWrappingKey,
WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};
var rawAesKeyring = matProv.CreateRawAesKeyring(createRawAesKeyringInput);
// 2. Create the AWS KMS keyring.
// We create a MRK multi keyring, as this interface also supports
// single-region KMS keys,
// and creates the KMS client for us automatically.
var createAwsKmsMrkMultiKeyringInput = new CreateAwsKmsMrkMultiKeyringInput
{
Generator = keyArn
};
var awsKmsMrkMultiKeyring = matProv.CreateAwsKmsMrkMultiKeyring(createAwsKmsMrkMultiKeyringInput);
```
------
#### [ Rust ]
```
// 1. Create the raw AES keyring
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
let raw_aes_keyring = mpl
.create_raw_aes_keyring()
.key_name("AES_256_012")
.key_namespace("HSM_01")
.wrapping_key(aes_key_bytes)
.wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
.send()
.await?;
// 2. Create the AWS KMS keyring
let aws_kms_mrk_multi_keyring = mpl
.create_aws_kms_mrk_multi_keyring()
.generator(key_arn)
.send()
.await?;
```
------
Crea quindi il keyring multiplo e specifica il keyring generatore, se presente. In questo esempio, creiamo un portachiavi multiplo in cui il portachiavi è il portachiavi del generatore e il AWS KMS portachiavi AES è il portachiavi per bambini.
------
#### [ Java ]
Il `CreateMultiKeyringInput` costruttore Java consente di definire un portachiavi del generatore e dei portachiavi secondari. L'`createMultiKeyringInput`oggetto risultante è immutabile.
```
final CreateMultiKeyringInput createMultiKeyringInput = CreateMultiKeyringInput.builder()
.generator(awsKmsMrkMultiKeyring)
.childKeyrings(Collections.singletonList(rawAesKeyring))
.build();
IKeyring multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ C\$1 / .NET ]
Il `CreateMultiKeyringInput` costruttore.NET consente di definire un portachiavi del generatore e dei portachiavi secondari. L'`CreateMultiKeyringInput`oggetto risultante è immutabile.
```
var createMultiKeyringInput = new CreateMultiKeyringInput
{
Generator = awsKmsMrkMultiKeyring,
ChildKeyrings = new List { rawAesKeyring }
};
var multiKeyring = matProv.CreateMultiKeyring(createMultiKeyringInput);
```
------
#### [ Rust ]
```
let multi_keyring = mpl
.create_multi_keyring()
.generator(aws_kms_mrk_multi_keyring)
.child_keyrings(vec![raw_aes_keyring.clone()])
.send()
.await?;
```
------
Ora puoi utilizzare il keyring multiplo per crittografare e decrittare i dati.