ECDHPorte-clés Raw

Le ECDH porte-clés Raw utilise les paires de clés publiques-privées à courbe elliptique que vous fournissez pour obtenir une clé d'encapsulation partagée entre deux parties. Tout d'abord, le trousseau de clés déduit un secret partagé à l'aide de la clé privée de l'expéditeur, de la clé publique du destinataire et de l'algorithme d'accord de clé Elliptic Curve Diffie-Hellman ()ECDH. Le trousseau de clés utilise ensuite le secret partagé pour dériver la clé d'encapsulation partagée qui protège vos clés de chiffrement des données. La fonction de dérivation de clé AWS Encryption SDK utilisée (KDF_CTR_HMAC_SHA384) pour dériver la clé d'encapsulation partagée est conforme aux NISTrecommandations pour la dérivation de clés.

La fonction de dérivation de clés renvoie 64 octets de contenu clé. Pour s'assurer que les deux parties utilisent le bon matériel clé, elles AWS Encryption SDK utilisent les 32 premiers octets comme clé d'engagement et les 32 derniers octets comme clé d'encapsulation partagée. Lors du déchiffrement, si le trousseau de clés ne peut pas reproduire la même clé d'engagement et la même clé d'encapsulation partagée que celles stockées dans le texte chiffré de l'en-tête du message, l'opération échoue. Par exemple, si vous chiffrez des données avec un trousseau de clés configuré avec la clé privée d'Alice et la clé publique de Bob, un trousseau de clés configuré avec la clé privée de Bob et la clé publique d'Alice reproduira la même clé d'engagement et la même clé d'encapsulation partagée et pourra déchiffrer les données. Si la clé publique de Bob provient d'une AWS KMS key paire, Bob peut créer un AWS KMS ECDHtrousseau de clés pour déchiffrer les données.

Le trousseau de ECDH clés Raw chiffre les données avec une clé symétrique en utilisant -. AES GCM La clé de données est ensuite cryptée par enveloppe avec la clé d'encapsulation partagée dérivée à l'aide de AES -GCM. Chaque ECDH porte-clés Raw ne peut avoir qu'une seule clé d'encapsulation partagée, mais vous pouvez inclure plusieurs ECDH porte-clés Raw, seuls ou avec d'autres porte-clés, dans un porte-clés multiple.

Vous êtes responsable de la génération, du stockage et de la protection de vos clés privées, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. Les paires de clés de l'expéditeur et du destinataire doivent se trouver sur la même courbe elliptique. Il AWS Encryption SDK prend en charge les spécifications de cuves elliptiques suivantes :

ECC_NIST_P256
ECC_NIST_P384
ECC_NIST_P512

Compatibilité avec les langages de programmation

Le trousseau de ECDH clés brut est introduit dans la version 1.5.0 de la bibliothèque des fournisseurs de matériel cryptographique (MPL) et est pris en charge par les langages de programmation et versions suivants :

Version 3. x du Kit SDK de chiffrement AWS pour Java
La version 4. x du AWS Encryption SDK formulaire. NET
La version 4. x du Kit SDK de chiffrement AWS pour Python, lorsqu'il est utilisé avec la MPL dépendance optionnelle.

Création d'un ECDH porte-clés Raw

Le trousseau de ECDH clés Raw prend en charge trois schémas d'accord clés :RawPrivateKeyToStaticPublicKey,EphemeralPrivateKeyToStaticPublicKey, et. PublicKeyDiscovery Le schéma d'accord de clé que vous sélectionnez détermine les opérations cryptographiques que vous pouvez effectuer et la manière dont les matériaux de clé sont assemblés.

RawPrivateKeyToStaticPublicKey

Utilisez le schéma d'accord des RawPrivateKeyToStaticPublicKey clés pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire dans le trousseau de clés. Ce schéma d'accord clé permet de chiffrer et de déchiffrer des données.

Pour initialiser un trousseau de ECDH clés brut avec le schéma d'accord de RawPrivateKeyToStaticPublicKey clés, fournissez les valeurs suivantes :

Clé privée de l'expéditeur

Vous devez fournir la clé privée PEM codée de l'expéditeur ( PrivateKeyInfo structures PKCS #8), telle que définie dans RFC5958.
Clé publique du destinataire

Vous devez fournir la clé publique X.509 DER codée du destinataire, également appelée SubjectPublicKeyInfo (SPKI), telle que définie dans RFC 5280.

Vous pouvez spécifier la clé publique d'une paire de clés à accord KMS de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
Spécification de la courbe

Identifie la spécification de la courbe elliptique dans les paires de clés spécifiées. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.

Valeurs valides: ECC_NIST_P256, ECC_NIS_P384, ECC_NIST_P512

C# / .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

L'exemple Java suivant utilise le schéma d'accord de RawPrivateKeyToStaticPublicKey clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés sont sur la ECC_NIST_P256 courbe.


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);
}

Python

L'exemple Python suivant utilise le schéma d'accord de RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés sont sur la ECC_NIST_P256 courbe.


import boto3
from aws_cryptographic_materialproviders.mpl.models import (
    CreateRawEcdhKeyringInput,
    RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey,
    RawPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Must be a PEM-encoded private key
bob_private_key = get_private_key_bytes()
# Must be a DER-encoded X.509 public key
alice_public_key = get_public_key_bytes()

# Create the raw ECDH static keyring
raw_keyring_input = CreateRawEcdhKeyringInput(
    curve_spec = ECDHCurveSpec.ECC_NIST_P256,
    key_agreement_scheme = RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey(
        RawPrivateKeyToStaticPublicKeyInput(
            sender_static_private_key = bob_private_key,
            recipient_public_key = alice_public_key,
        )
    )
)

keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)

EphemeralPrivateKeyToStaticPublicKey

Les porte-clés configurés avec le schéma d'accord de EphemeralPrivateKeyToStaticPublicKey clés créent une nouvelle paire de clés localement et dérivent une clé d'encapsulation partagée unique pour chaque appel de chiffrement.

Ce schéma d'accord clé ne peut chiffrer que les messages. Pour déchiffrer les messages chiffrés avec le schéma d'accord de EphemeralPrivateKeyToStaticPublicKey clé, vous devez utiliser un schéma d'accord de clé de découverte configuré avec la clé publique du même destinataire. Pour le déchiffrer, vous pouvez utiliser un trousseau de ECDH clés brut avec l'algorithme d'accord de PublicKeyDiscoveryclés ou, si la clé publique du destinataire provient d'une paire de clés d'accord de clé asymétrique, vous pouvez utiliser un AWS KMS ECDH trousseau de KMS clés avec le KmsPublicKeyDiscoveryschéma d'accord de clés.

Pour initialiser un trousseau de ECDH clés brut avec le schéma d'accord de EphemeralPrivateKeyToStaticPublicKey clés, fournissez les valeurs suivantes :

Clé publique du destinataire

Vous devez fournir la clé publique X.509 DER codée du destinataire, également appelée SubjectPublicKeyInfo (SPKI), telle que définie dans RFC 5280.

Vous pouvez spécifier la clé publique d'une paire de clés à accord KMS de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
Spécification de la courbe

Identifie la spécification de la courbe elliptique dans la clé publique spécifiée.

Lors du chiffrement, le trousseau de clés crée une nouvelle paire de clés sur la courbe spécifiée et utilise la nouvelle clé privée et la clé publique spécifiée pour dériver une clé d'encapsulation partagée.

Valeurs valides: ECC_NIST_P256, ECC_NIS_P384, ECC_NIST_P512

C# / .NET

L'exemple suivant crée un trousseau de ECDH clés brut avec le schéma d'accord de EphemeralPrivateKeyToStaticPublicKey clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiéeECC_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


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);
}

Python

L'exemple suivant crée un trousseau de ECDH clés brut avec le schéma d'accord de RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiéeECC_NIST_P256.


import boto3
from aws_cryptographic_materialproviders.mpl.models import (
    CreateRawEcdhKeyringInput,
    RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey,
    EphemeralPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Your get_public_key_bytes must return a DER-encoded X.509 public key
recipient_public_key = get_public_key_bytes()

# Create the raw ECDH ephemeral private key keyring
ephemeral_input = CreateRawEcdhKeyringInput(
    curve_spec = ECDHCurveSpec.ECC_NIST_P256,
    key_agreement_scheme = RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey(
        EphemeralPrivateKeyToStaticPublicKeyInput(
            recipient_public_key = recipient_public_key,
        )
    )
)

keyring = mat_prov.create_raw_ecdh_keyring(ephemeral_input)

PublicKeyDiscovery

Lors du déchiffrement, il est recommandé de spécifier les clés d'encapsulation qu'ils peuvent utiliser. AWS Encryption SDK Pour suivre cette bonne pratique, utilisez un ECDH trousseau de clés qui spécifie à la fois la clé privée de l'expéditeur et la clé publique du destinataire. Cependant, vous pouvez également créer un jeu de clés de ECDH découverte brut, c'est-à-dire un jeu de ECDH clés brut capable de déchiffrer tout message dont la clé publique spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message. Ce schéma d'accord clé ne peut que déchiffrer les messages.

Important

Lorsque vous déchiffrez des messages à l'aide du schéma d'accord de PublicKeyDiscovery clés, vous acceptez toutes les clés publiques, quel que soit leur propriétaire.

Pour initialiser un trousseau de ECDH clés brut avec le schéma d'accord de PublicKeyDiscovery clés, fournissez les valeurs suivantes :

Clé privée statique du destinataire

Vous devez fournir la clé privée PEM codée du destinataire ( PrivateKeyInfo structures PKCS #8), telle que définie dans RFC5958.
Spécification de la courbe

Identifie la spécification de la courbe elliptique dans la clé privée spécifiée. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.

Valeurs valides: ECC_NIST_P256, ECC_NIS_P384, ECC_NIST_P512

C# / .NET

L'exemple suivant crée un trousseau de ECDH clés brut avec le schéma d'accord de PublicKeyDiscovery clés. Ce porte-clés peut déchiffrer tout message dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.


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


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);
}

Python

L'exemple suivant crée un trousseau de ECDH clés brut avec le schéma d'accord de RawEcdhStaticConfigurationsPublicKeyDiscovery clés. Ce porte-clés peut déchiffrer tout message dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.


import boto3
from aws_cryptographic_materialproviders.mpl.models import (
    CreateRawEcdhKeyringInput,
    RawEcdhStaticConfigurationsPublicKeyDiscovery,
    PublicKeyDiscoveryInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec

# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Your get_private_key_bytes must return a PEM-encoded private key
recipient_private_key = get_private_key_bytes()

# Create the raw ECDH discovery keyring
raw_keyring_input = CreateRawEcdhKeyringInput(
    curve_spec = ECDHCurveSpec.ECC_NIST_P256,
    key_agreement_scheme = RawEcdhStaticConfigurationsPublicKeyDiscovery(
        PublicKeyDiscoveryInput(
            recipient_static_private_key = recipient_private_key,
        )
    )
)

keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

RSAPorte-clés Raw

Porte-clés multiples