Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Llaveros ECDH sin procesar **** | | | --- | | Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de bases de AWS datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el [cliente de cifrado de DynamoDB](legacy-dynamodb-encryption-client.md). | **importante** El conjunto de claves ECDH sin procesar solo está disponible en la versión 1.5.0 de la biblioteca de proveedores de materiales. El anillo de claves ECDH sin procesar utiliza los pares de claves público-privadas de curva elíptica que usted proporciona para obtener una clave de empaquetado compartida entre dos partes. En primer lugar, el conjunto de claves obtiene un secreto compartido mediante la clave privada del remitente, la clave pública del destinatario y el algoritmo de acuerdo de claves Elliptic Curve Diffie-Hellman (ECDH). A continuación, el conjunto de claves utiliza el secreto compartido para obtener la clave de empaquetado compartida que protege las claves de cifrado de datos. La función de derivación de claves que utiliza el SDK de cifrado de AWS bases de datos (`KDF_CTR_HMAC_SHA384`) para derivar la clave de empaquetado compartida cumple con las [recomendaciones del NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) para la derivación de claves. La función de derivación de claves devuelve 64 bytes de material de creación de claves. Para garantizar que ambas partes utilicen el material de codificación correcto, el SDK de cifrado de AWS bases de datos utiliza los primeros 32 bytes como clave de compromiso y los últimos 32 bytes como clave de empaquetado compartida. Al descifrar, si el conjunto de claves no puede reproducir la misma clave de compromiso y la misma clave de empaquetado compartida que están almacenadas en el campo de descripción del material del registro cifrado, la operación falla. Por ejemplo, si cifra un registro con un conjunto de claves configurado con la clave privada **de Alice** y la clave pública **de Bob**, un conjunto de claves configurado con la clave privada **de Bob** y la clave pública **de Alice** reproducirá la misma clave de compromiso y clave de empaquetado compartida y podrá descifrar el registro. Si la clave pública de Bob proviene de un AWS KMS key par, Bob puede crear un conjunto de [claves AWS KMS ECDH](use-kms-ecdh-keyring.md) para descifrar el registro. El conjunto de claves ECDH sin procesar cifra los registros con una clave simétrica mediante AES-GCM. A continuación, la clave de datos se cifra sobre con la clave de empaquetado compartida derivada mediante AES-GCM. [Cada anillo de claves ECDH sin procesar solo puede tener una clave de empaquetado compartida, pero puede incluir varios anillos de claves ECDH sin procesar, solos o con otros, en un conjunto de claves múltiples.](use-multi-keyring.md) Usted es responsable de generar, almacenar y proteger sus claves privadas, preferiblemente en un módulo de seguridad de hardware (HSM) o en un sistema de administración de claves. Los pares de claves del remitente y del destinatario deben estar en la misma curva elíptica. El SDK AWS de cifrado de bases de datos admite las siguientes especificaciones de curva elíptica: + `ECC_NIST_P256` + `ECC_NIST_P384` + `ECC_NIST_P512` ## Creación de un conjunto de claves ECDH sin procesar El anillo de claves ECDH sin procesar admite tres esquemas de acuerdo clave:, y. `RawPrivateKeyToStaticPublicKey` `EphemeralPrivateKeyToStaticPublicKey` `PublicKeyDiscovery` El esquema de acuerdo de claves que seleccione determina qué operaciones criptográficas puede realizar y cómo se ensamblan los materiales de codificación. **Topics** + [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey) + [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey) + [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery) ### RawPrivateKeyToStaticPublicKey Utilice el esquema de acuerdo de `RawPrivateKeyToStaticPublicKey` claves para configurar de forma estática la clave privada del remitente y la clave pública del destinatario en el conjunto de claves. Este esquema de acuerdo de claves puede cifrar y descifrar registros. Para inicializar un conjunto de claves ECDH sin procesar con el esquema de acuerdo de `RawPrivateKeyToStaticPublicKey` claves, proporcione los siguientes valores: + **Clave privada del remitente** [Debe proporcionar la clave privada codificada en PEM del remitente ( PrivateKeyInfo estructuras PKCS \$18), tal como se define en el RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2) + **La clave pública del destinatario** [Debe proporcionar la clave pública X.509 codificada en DER del destinatario, también conocida como `SubjectPublicKeyInfo` (SPKI), tal como se define en el RFC 5280.](https://tools.ietf.org/html/rfc5280) Puede especificar la clave pública de un par de claves KMS de un acuerdo de claves asimétrico o la clave pública de un par de claves generado fuera de AWS. + **Especificación de curva** Identifica la especificación de la curva elíptica en los pares de claves especificados. Los pares de claves del remitente y del destinatario deben tener la misma especificación de curva. Valores válidos: `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 ] El siguiente ejemplo de Java utiliza el esquema de acuerdo de `RawPrivateKeyToStaticPublicKey` claves para configurar estáticamente la clave privada del remitente y la clave pública del destinatario. Ambos pares de claves están en la `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 ] El siguiente ejemplo de Python usa el esquema de acuerdo de `raw_ecdh_static_configuration` claves para configurar estáticamente la clave privada del remitente y la clave pública del destinatario. Ambos pares de claves deben estar en la misma 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 Los conjuntos de `EphemeralPrivateKeyToStaticPublicKey` claves configurados con el esquema de acuerdo de claves crean un nuevo par de claves localmente y derivan una clave de empaquetado compartida única para cada llamada de cifrado. Este esquema de acuerdo de claves solo puede cifrar registros. Para descifrar los registros cifrados con el esquema de acuerdo de `EphemeralPrivateKeyToStaticPublicKey` claves, debe utilizar un esquema de acuerdo de claves de descubrimiento configurado con la clave pública del mismo destinatario. Para descifrar, puede usar un anillo de claves ECDH sin procesar con el algoritmo de acuerdo de claves o, si la [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)clave pública del destinatario proviene de un par de claves KMS de acuerdo de claves asimétrico, puede usar un anillo de claves AWS KMS ECDH con el esquema de acuerdo de claves. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery) Para inicializar un conjunto de claves ECDH sin procesar con el esquema de acuerdo de claves, proporcione los siguientes valores`EphemeralPrivateKeyToStaticPublicKey`: + **Clave pública del destinatario** [Debe proporcionar la clave pública X.509 codificada en DER del destinatario, también conocida como `SubjectPublicKeyInfo` (SPKI), tal como se define en el RFC 5280.](https://tools.ietf.org/html/rfc5280) Puede especificar la clave pública de un par de claves KMS de un acuerdo de claves asimétrico o la clave pública de un par de claves generado fuera de AWS. + **Especificación de curva** Identifica la especificación de la curva elíptica en la clave pública especificada. Al cifrar, el anillo de claves crea un nuevo par de claves en la curva especificada y utiliza la nueva clave privada y la clave pública especificada para obtener una clave de empaquetado compartida. Valores válidos: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512` ------ #### [ C\$1 / .NET ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el `EphemeralPrivateKeyToStaticPublicKey` esquema de acuerdo de claves. Al cifrar, el anillo de claves creará un nuevo par de claves localmente en la curva especificada`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 ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el `EphemeralPrivateKeyToStaticPublicKey` esquema de acuerdo de claves. Al cifrar, el anillo de claves creará un nuevo par de claves localmente en la curva especificada`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 ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el `ephemeral_raw_ecdh_static_configuration` esquema de acuerdo de claves. Al cifrar, el anillo de claves creará un nuevo par de claves localmente en la curva especificada. ``` // 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 Al descifrar, se recomienda especificar las claves de empaquetado que puede usar el SDK de cifrado de AWS bases de datos. Para seguir esta práctica recomendada, utilice un conjunto de claves ECDH que especifique tanto la clave privada del remitente como la clave pública del destinatario. Sin embargo, también puede crear un conjunto de claves de detección de ECDH sin procesar, es decir, un conjunto de claves ECDH sin procesar que pueda descifrar cualquier registro en el que la clave pública de la clave especificada coincida con la clave pública del destinatario almacenada en el campo de descripción del material del registro cifrado. Este esquema de acuerdo de claves solo puede descifrar registros. **importante** Al descifrar registros mediante el esquema de acuerdo de `PublicKeyDiscovery` claves, acepta todas las claves públicas, independientemente de quién sea su propietario. Para inicializar un conjunto de claves ECDH sin procesar con el esquema de acuerdo de `PublicKeyDiscovery` claves, proporcione los siguientes valores: + **Clave privada estática del destinatario** [Debe proporcionar la clave privada codificada en PEM del destinatario ( PrivateKeyInfo estructuras PKCS \$18), tal como se define en el RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2) + **Especificación de curva** Identifica la especificación de la curva elíptica en la clave privada especificada. Los pares de claves del remitente y del destinatario deben tener la misma especificación de curva. Valores válidos: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512` ------ #### [ C\$1 / .NET ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el esquema de acuerdo de `PublicKeyDiscovery` claves. Este conjunto de claves puede descifrar cualquier registro en el que la clave pública de la clave privada especificada coincida con la clave pública del destinatario almacenada en el campo de descripción del material del registro cifrado. ``` // 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 ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el `PublicKeyDiscovery` esquema de acuerdo de claves. Este conjunto de claves puede descifrar cualquier registro en el que la clave pública de la clave privada especificada coincida con la clave pública del destinatario almacenada en el campo de descripción del material del registro cifrado. ``` 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 ] En el siguiente ejemplo, se crea un anillo de claves ECDH sin procesar con el `discovery_raw_ecdh_static_configuration` esquema de acuerdo de claves. Este conjunto de claves puede descifrar cualquier mensaje en el que la clave pública de la clave privada especificada coincida con la clave pública del destinatario almacenada en el texto cifrado del mensaje. ``` // 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?; ``` ------