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 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?; ``` ------