ECDHPortachiavi Raw - AWS Crittografia database SDK
Creazione di un portachiavi Raw ECDH

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à.

ECDHPortachiavi Raw

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

Il ECDH portachiavi Raw è disponibile solo con la versione 1.5.0 della Material Providers Library.

Il ECDH portachiavi Raw 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 chiave Elliptic Curve Diffie-Hellman (). ECDH 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 SDK utilizzata da AWS Database Encryption (KDF_CTR_HMAC_SHA384) per derivare la chiave di wrapping condivisa è conforme alle raccomandazioni per la derivazione delle chiavi. NIST

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, la crittografia del AWS database SDK utilizza i primi 32 byte come chiave di commit e gli ultimi 32 byte come chiave di wrapping condivisa. In fase di decrittografia, se il portachiavi non è in grado di riprodurre la stessa chiave di commit 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 portachiavi per decrittografare il record.AWS KMS ECDH

Il ECDH portachiavi Raw crittografa i record con una chiave simmetrica usando -. AES GCM La chiave dati viene quindi crittografata in busta con la chiave di wrapping condivisa derivata utilizzando -. AES GCM Ogni ECDH portachiavi Raw può avere solo una chiave di imballaggio condivisa, ma puoi includere più portachiavi Raw, da soli o con altri ECDH portachiavi, in un portachiavi multiplo.

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. La crittografia del AWS database SDK supporta le seguenti specifiche della curva ellittica:

  • ECC_NIST_P256

  • ECC_NIST_P384

  • ECC_NIST_P512

Creazione di un portachiavi Raw ECDH

Il ECDH portachiavi Raw supporta tre schemi di accordo chiave:RawPrivateKeyToStaticPublicKey, EphemeralPrivateKeyToStaticPublicKey e. 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.

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 ECDH portachiavi Raw con lo schema degli accordi RawPrivateKeyToStaticPublicKey chiave, fornisci i seguenti valori:

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

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

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, puoi utilizzare un ECDH portachiavi Raw con l'algoritmo di accordo PublicKeyDiscoverychiave oppure, se la chiave pubblica del destinatario proviene da una KMS coppia di chiavi asimmetrica, puoi utilizzare AWS KMS ECDH un portachiavi con lo schema di accordo chiave. KmsPublicKeyDiscovery

Per inizializzare un portachiavi ECDH Raw con lo schema di accordo chiave, fornisci i seguenti valoriEphemeralPrivateKeyToStaticPublicKey:

C# / .NET

L'esempio seguente crea un portachiavi Raw con lo schema di ECDH accordo delle chiavi. EphemeralPrivateKeyToStaticPublicKey Su encrypt, il portachiavi creerà una nuova coppia di chiavi localmente sulla curva specificataECC_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 ECDH portachiavi Raw con lo schema di accordo delle EphemeralPrivateKeyToStaticPublicKey chiavi. Su encrypt, il portachiavi creerà una nuova coppia di chiavi localmente sulla curva specificataECC_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);
}

PublicKeyDiscovery

Durante la decrittografia, è consigliabile specificare le chiavi di wrapping che la crittografia del AWS database può utilizzare. SDK Per seguire questa procedura ottimale, utilizzate un ECDH portachiavi 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 Raw ECDH 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 accordo 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 ECDH portachiavi Raw con lo schema degli accordi PublicKeyDiscovery chiave, fornisci i seguenti valori:

C# / .NET

L'esempio seguente crea un ECDH portachiavi Raw con lo schema di accordo delle PublicKeyDiscovery chiavi. Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della chiave privata 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());
	    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 Raw con lo schema di accordo delle ECDH PublicKeyDiscovery chiavi. Questo portachiavi può decrittografare qualsiasi record in cui la chiave pubblica della chiave privata specificata corrisponde 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);
}