Partager via

CryptographyAsyncClient Classe

  • Référence
Paquet:
com.azure.security.keyvault.keys.cryptography
Artefact Maven:
com.azure:azure-security-keyvault-keys:4.7.3
  • java.lang.Object
    • com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient

public class CryptographyAsyncClient

Fournit CryptographyAsyncClient des méthodes asynchrones pour effectuer des opérations de chiffrement à l’aide de clés asymétriques et symétriques. Le client prend en charge les opérations de chiffrement, de déchiffrement, de wrap key, d’unwrap key, de signature et de vérification à l’aide de la clé configurée.

Mise en route

Pour interagir avec le service Azure Key Vault, vous devez créer un instance de la CryptographyAsyncClient classe, une URL de coffre et un objet d’informations d’identification.

Les exemples présentés dans ce document utilisent un objet d’informations d’identification nommé DefaultAzureCredential pour l’authentification, ce qui est approprié pour la plupart des scénarios, y compris les environnements de développement et de production locaux. En outre, nous vous recommandons d’utiliser une identité managée pour l’authentification dans les environnements de production. Vous trouverez plus d’informations sur les différentes méthodes d’authentification et leurs types d’informations d’identification correspondants dans la documentation Azure Identity .

Exemple : Construire un client de chiffrement asynchrone

L’exemple de code suivant illustre la création d’un CryptographyAsyncClient, à l’aide de pour le CryptographyClientBuilder configurer.

CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
     .keyIdentifier("<your-key-id>")
     .credential(new DefaultAzureCredentialBuilder().build())
     .buildAsyncClient();

JsonWebKey jsonWebKey = new JsonWebKey().setId("SampleJsonWebKey");
 CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
     .jsonWebKey(jsonWebKey)
     .buildAsyncClient();

Chiffrer les données

Peut être utilisé pour chiffrer des CryptographyAsyncClient données.

Exemple de code :

L’exemple de code suivant montre comment chiffrer de manière asynchrone des données à l’aide de l’API encrypt(EncryptionAlgorithm algorithm, byte[] plaintext) .

byte[] plaintext = new byte[100];
 new Random(0x1234567L).nextBytes(plaintext);

 cryptographyAsyncClient.encrypt(EncryptionAlgorithm.RSA_OAEP, plaintext)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(encryptResult ->
         System.out.printf("Received encrypted content of length: %d, with algorithm: %s.%n",
             encryptResult.getCipherText().length, encryptResult.getAlgorithm().toString()));

Note: Pour l’exemple synchrone, reportez-vous à CryptographyClient.

Déchiffrer les données

Peut être utilisé pour déchiffrer des CryptographyAsyncClient données.

Exemple de code :

L’exemple de code suivant montre comment déchiffrer de manière asynchrone des données à l’aide de l’API decrypt(EncryptionAlgorithm algorithm, byte[] ciphertext) .

byte[] ciphertext = new byte[100];
 new Random(0x1234567L).nextBytes(ciphertext);

 cryptographyAsyncClient.decrypt(EncryptionAlgorithm.RSA_OAEP, ciphertext)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(decryptResult ->
         System.out.printf("Received decrypted content of length: %d%n", decryptResult.getPlainText().length));

Note: Pour l’exemple synchrone, reportez-vous à CryptographyClient.

Résumé de la méthode

Modificateur et type Méthode et description
Mono<DecryptResult> decrypt(DecryptParameters decryptParameters)

Déchiffre un seul bloc de données chiffrées à l’aide de la clé configurée et de l’algorithme spécifié.
Mono<DecryptResult> decrypt(EncryptionAlgorithm algorithm, byte[] ciphertext)

Déchiffre un seul bloc de données chiffrées à l’aide de la clé configurée et de l’algorithme spécifié.
Mono<EncryptResult> encrypt(EncryptParameters encryptParameters)

Chiffre une séquence arbitraire d’octets à l’aide de la clé configurée.
Mono<EncryptResult> encrypt(EncryptionAlgorithm algorithm, byte[] plaintext)

Chiffre une séquence arbitraire d’octets à l’aide de la clé configurée.
Mono<KeyVaultKey> getKey()

Obtient la partie publique de la clé configurée.
Mono<Response<KeyVaultKey>> getKeyWithResponse()

Obtient la partie publique de la clé configurée.
Mono<SignResult> sign(SignatureAlgorithm algorithm, byte[] digest)

Crée une signature à partir d’un digest à l’aide de la clé configurée.
Mono<SignResult> signData(SignatureAlgorithm algorithm, byte[] data)

Crée une signature à partir des données brutes à l’aide de la clé configurée.
Mono<UnwrapResult> unwrapKey(KeyWrapAlgorithm algorithm, byte[] encryptedKey)

Désencapsule une clé symétrique à l’aide de la clé configurée qui a été initialement utilisée pour l’encapsulage de cette clé.
Mono<VerifyResult> verify(SignatureAlgorithm algorithm, byte[] digest, byte[] signature)

Vérifie une signature à l’aide de la clé configurée.
Mono<VerifyResult> verifyData(SignatureAlgorithm algorithm, byte[] data, byte[] signature)

Vérifie une signature par rapport aux données brutes à l’aide de la clé configurée.
Mono<WrapResult> wrapKey(KeyWrapAlgorithm algorithm, byte[] key)

Encapsule une clé symétrique à l’aide de la clé configurée.

Méthodes héritées de java.lang.Object

clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Détails de la méthode

decrypt

public Mono decrypt(DecryptParameters decryptParameters)

Déchiffre un seul bloc de données chiffrées à l’aide de la clé configurée et de l’algorithme spécifié. Notez qu’un seul bloc de données peut être déchiffré, la taille de ce bloc dépend de la clé cible et de l’algorithme à utiliser. L’opération de déchiffrement est prise en charge pour les clés asymétriques et symétriques. Cette opération nécessite l’autorisation keys/decrypt pour les opérations non locales.

indique EncryptionAlgorithm le type d’algorithme à utiliser pour déchiffrer le contenu chiffré spécifié. Les valeurs possibles pour les clés asymétriques sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128CBC, A128CBC_HS256A128CBCPAD, A128GCM, A192CBC, A256CBCA192GCMA192CBC_HS384A256CBCPADA192CBCPAD, et .A256GCMA256CBC_HS512

Exemples de code

Déchiffre le contenu chiffré. S’abonne à l’appel de manière asynchrone et imprime les détails du contenu déchiffré lorsqu’une réponse a été reçue.

byte[] ciphertextBytes = new byte[100];
 new Random(0x1234567L).nextBytes(ciphertextBytes);
 byte[] iv = {
     (byte) 0x1a, (byte) 0xf3, (byte) 0x8c, (byte) 0x2d, (byte) 0xc2, (byte) 0xb9, (byte) 0x6f, (byte) 0xfd,
     (byte) 0xd8, (byte) 0x66, (byte) 0x94, (byte) 0x09, (byte) 0x23, (byte) 0x41, (byte) 0xbc, (byte) 0x04
 };

 DecryptParameters decryptParameters = DecryptParameters.createA128CbcParameters(ciphertextBytes, iv);

 cryptographyAsyncClient.decrypt(decryptParameters)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(decryptResult ->
         System.out.printf("Received decrypted content of length: %d.%n", decryptResult.getPlainText().length));

Parameters:

decryptParameters - Paramètres à utiliser dans l’opération de déchiffrement. Microsoft recommande de ne pas utiliser CBC sans garantir au préalable l’intégrité du texte chiffré à l’aide d’un HMAC, par exemple. Pour plus d’informations, consultez Minutage des vulnérabilités avec le déchiffrement symétrique en mode CBC à l’aide du remplissage .

Returns:

Mono contenant l’objet blob déchiffré.

decrypt

public Mono decrypt(EncryptionAlgorithm algorithm, byte[] ciphertext)

Déchiffre un seul bloc de données chiffrées à l’aide de la clé configurée et de l’algorithme spécifié. Notez qu’un seul bloc de données peut être déchiffré, la taille de ce bloc dépend de la clé cible et de l’algorithme à utiliser. L’opération de déchiffrement est prise en charge pour les clés asymétriques et symétriques. Cette opération nécessite l’autorisation keys/decrypt pour les opérations non locales.

indique EncryptionAlgorithm le type d’algorithme à utiliser pour déchiffrer le contenu chiffré spécifié. Les valeurs possibles pour les clés asymétriques sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128CBC, A128CBC_HS256A128CBCPAD, A128GCM, A192CBC, A256CBCA192GCMA192CBC_HS384A256CBCPADA192CBCPAD, et .A256GCMA256CBC_HS512

Exemples de code

Déchiffre le contenu chiffré. S’abonne à l’appel de manière asynchrone et imprime les détails du contenu déchiffré lorsqu’une réponse a été reçue.

byte[] ciphertext = new byte[100];
 new Random(0x1234567L).nextBytes(ciphertext);

 cryptographyAsyncClient.decrypt(EncryptionAlgorithm.RSA_OAEP, ciphertext)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(decryptResult ->
         System.out.printf("Received decrypted content of length: %d%n", decryptResult.getPlainText().length));

Parameters:

algorithm - Algorithme à utiliser pour le déchiffrement.
ciphertext - Contenu à déchiffrer. Microsoft recommande de ne pas utiliser CBC sans garantir au préalable l’intégrité du texte chiffré à l’aide d’un HMAC, par exemple. Pour plus d’informations, consultez Minutage des vulnérabilités avec le déchiffrement symétrique en mode CBC à l’aide du remplissage .

Returns:

Mono contenant l’objet blob déchiffré.

encrypt

public Mono encrypt(EncryptParameters encryptParameters)

Chiffre une séquence arbitraire d’octets à l’aide de la clé configurée. Notez que l’opération de chiffrement ne prend en charge qu’un seul bloc de données, dont la taille dépend de la clé cible et de l’algorithme de chiffrement à utiliser. L’opération de chiffrement est prise en charge pour les clés symétriques et les clés asymétriques. En cas de clés asymétriques, la partie publique de la clé est utilisée pour le chiffrement. Cette opération nécessite l’autorisation keys/encrypt pour les opérations non locales.

indique EncryptionAlgorithm le type d’algorithme à utiliser pour chiffrer le spécifié plaintext. Les valeurs possibles pour les clés asymétriques sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128CBC, A128CBC_HS256A128CBCPAD, A128GCM, A192CBC, A256CBCA192GCMA192CBC_HS384A256CBCPADA192CBCPAD, et .A256GCMA256CBC_HS512

Exemples de code

Chiffre le contenu. S’abonne à l’appel de manière asynchrone et imprime les détails du contenu chiffré lorsqu’une réponse a été reçue.

byte[] plaintextBytes = new byte[100];
 new Random(0x1234567L).nextBytes(plaintextBytes);
 byte[] iv = {
     (byte) 0x1a, (byte) 0xf3, (byte) 0x8c, (byte) 0x2d, (byte) 0xc2, (byte) 0xb9, (byte) 0x6f, (byte) 0xfd,
     (byte) 0xd8, (byte) 0x66, (byte) 0x94, (byte) 0x09, (byte) 0x23, (byte) 0x41, (byte) 0xbc, (byte) 0x04
 };

 EncryptParameters encryptParameters = EncryptParameters.createA128CbcParameters(plaintextBytes, iv);

 cryptographyAsyncClient.encrypt(encryptParameters)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(encryptResult ->
         System.out.printf("Received encrypted content of length: %d, with algorithm: %s.%n",
             encryptResult.getCipherText().length, encryptResult.getAlgorithm().toString()));

Parameters:

encryptParameters - Paramètres à utiliser dans l’opération de chiffrement.

Returns:

Mono contenant un EncryptResult dont getCipherText() contient le contenu chiffré.

encrypt

public Mono encrypt(EncryptionAlgorithm algorithm, byte[] plaintext)

Chiffre une séquence arbitraire d’octets à l’aide de la clé configurée. Notez que l’opération de chiffrement ne prend en charge qu’un seul bloc de données, dont la taille dépend de la clé cible et de l’algorithme de chiffrement à utiliser. L’opération de chiffrement est prise en charge pour les clés symétriques et les clés asymétriques. En cas de clés asymétriques, la partie publique de la clé est utilisée pour le chiffrement. Cette opération nécessite l’autorisation keys/encrypt pour les opérations non locales.

indique EncryptionAlgorithm le type d’algorithme à utiliser pour chiffrer le spécifié plaintext. Les valeurs possibles pour les clés asymétriques sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128CBC, A128CBC_HS256A128CBCPAD, A128GCM, A192CBC, A256CBCA192GCMA192CBC_HS384A256CBCPADA192CBCPAD, et .A256GCMA256CBC_HS512

Exemples de code

Chiffre le contenu. S’abonne à l’appel de façon asynchrone et imprime les détails du contenu chiffré lorsqu’une réponse a été reçue.

byte[] plaintext = new byte[100];
 new Random(0x1234567L).nextBytes(plaintext);

 cryptographyAsyncClient.encrypt(EncryptionAlgorithm.RSA_OAEP, plaintext)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(encryptResult ->
         System.out.printf("Received encrypted content of length: %d, with algorithm: %s.%n",
             encryptResult.getCipherText().length, encryptResult.getAlgorithm().toString()));

Parameters:

algorithm - Algorithme à utiliser pour le chiffrement.
plaintext - Contenu à chiffrer.

Returns:

Mono contenant un EncryptResult dont getCipherText() contient le contenu chiffré.

getKey

public Mono getKey()

Obtient la partie publique de la clé configurée. L’opération get key s’applique à tous les types de clés et nécessite l’autorisation keys/get pour les opérations non locales.

Exemples de code

Obtient la clé configurée dans le client. S’abonne à l’appel de façon asynchrone et affiche les détails de la clé retournée lorsqu’une réponse a été reçue.

cryptographyAsyncClient.getKey()
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(key ->
         System.out.printf("Key returned with name: %s, and id: %s.%n", key.getName(), key.getId()));

Returns:

Mono contenant le demandéKeyVaultKey.

getKeyWithResponse

public Mono> getKeyWithResponse()

Obtient la partie publique de la clé configurée. L’opération get key s’applique à tous les types de clés et nécessite l’autorisation keys/get pour les opérations non locales.

Exemples de code

Obtient la clé configurée dans le client. S’abonne à l’appel de façon asynchrone et affiche les détails de la clé retournée lorsqu’une réponse a été reçue.

cryptographyAsyncClient.getKeyWithResponse()
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(keyResponse ->
         System.out.printf("Key returned with name: %s, and id: %s.%n", keyResponse.getValue().getName(),
             keyResponse.getValue().getId()));

Returns:

Mono contenant un Response<T> dont value contient le demandéKeyVaultKey.

sign

public Mono sign(SignatureAlgorithm algorithm, byte[] digest)

Crée une signature à partir d’un digest à l’aide de la clé configurée. L’opération de signature prend en charge les clés asymétriques et symétriques. Cette opération nécessite l’autorisation pour les keys/sign opérations non locales.

indique SignatureAlgorithm le type d’algorithme à utiliser pour créer la signature à partir du digest. Les valeurs possibles sont les suivantes : ES256, ES512ES384, ES256K, PS256, RS512RS384, RS256, , RS384et RS512.

Exemples de code

Chante la synthèse. S’abonne à l’appel de façon asynchrone et imprime les détails de la signature lorsqu’une réponse a été reçue.

byte[] data = new byte[100];
 new Random(0x1234567L).nextBytes(data);
 MessageDigest md = MessageDigest.getInstance("SHA-256");
 md.update(data);
 byte[] digest = md.digest();

 cryptographyAsyncClient.sign(SignatureAlgorithm.ES256, digest)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(signResult ->
         System.out.printf("Received signature of length: %d, with algorithm: %s.%n",
             signResult.getSignature().length, signResult.getAlgorithm()));

Parameters:

algorithm - Algorithme à utiliser pour la signature.
digest - Contenu à partir duquel la signature doit être créée.

Returns:

Mono contenant un SignResult dont getSignature() contient la signature créée.

signData

public Mono signData(SignatureAlgorithm algorithm, byte[] data)

Crée une signature à partir des données brutes à l’aide de la clé configurée. L’opération de données de signature prend en charge les clés asymétriques et symétriques. Cette opération nécessite l’autorisation pour les keys/sign opérations non locales.

indique SignatureAlgorithm le type d’algorithme à utiliser pour signer le digest. Les valeurs possibles sont les suivantes : ES256, ES512ES384, ES256K, PS256, RS512RS384, RS256, , RS384et RS512.

Exemples de code

Signe les données brutes. S’abonne à l’appel de façon asynchrone et imprime les détails de la signature lorsqu’une réponse a été reçue.

byte[] data = new byte[100];
 new Random(0x1234567L).nextBytes(data);

 cryptographyAsyncClient.sign(SignatureAlgorithm.ES256, data)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(signResult ->
         System.out.printf("Received signature of length: %d, with algorithm: %s.%n",
             signResult.getSignature().length, signResult.getAlgorithm()));

Parameters:

algorithm - Algorithme à utiliser pour la signature.
data - Contenu à partir duquel la signature doit être créée.

Returns:

Mono contenant un SignResult dont getSignature() contient la signature créée.

unwrapKey

public Mono unwrapKey(KeyWrapAlgorithm algorithm, byte[] encryptedKey)

Désencapsule une clé symétrique à l’aide de la clé configurée qui a été initialement utilisée pour l’encapsulage de cette clé. Cette opération est l’inverse de l’opération wrap. L’opération unwrap prend en charge les clés asymétriques et symétriques à désencapsuler. Cette opération nécessite l’autorisation pour les keys/unwrapKey opérations non locales.

Indique KeyWrapAlgorithm le type d’algorithme à utiliser pour désencapsuler le contenu de clé chiffrée spécifié. Les valeurs possibles pour les clés asymétriques sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128KW, A192KW et A256KW.

Exemples de code

Désencapsule le contenu de la clé. S’abonne à l’appel de façon asynchrone et affiche les détails de la clé non-utilisée lorsqu’une réponse a été reçue.

byte[] keyToWrap = new byte[100];
 new Random(0x1234567L).nextBytes(key);

 cryptographyAsyncClient.wrapKey(KeyWrapAlgorithm.RSA_OAEP, keyToWrap)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(wrapResult ->
         cryptographyAsyncClient.unwrapKey(KeyWrapAlgorithm.RSA_OAEP, wrapResult.getEncryptedKey())
             .subscribe(keyUnwrapResult ->
                 System.out.printf("Received key of length: %d.%n", keyUnwrapResult.getKey().length)));

Parameters:

algorithm - Algorithme de chiffrement à utiliser pour l’encapsulage de la clé.
encryptedKey - Contenu de clé chiffrée à désencapsuler.

Returns:

Mono contenant un UnwrapResult dont decrypted key contient le résultat de la clé non-exploitée.

verify

public Mono verify(SignatureAlgorithm algorithm, byte[] digest, byte[] signature)

Vérifie une signature à l’aide de la clé configurée. L’opération de vérification prend en charge les clés symétriques et les clés asymétriques. Dans le cas de clés asymétriques, la partie publique de la clé est utilisée pour vérifier la signature. Cette opération nécessite l’autorisation pour les keys/verify opérations non locales.

indique SignatureAlgorithm le type d’algorithme à utiliser pour vérifier la signature. Les valeurs possibles sont les suivantes : ES256, ES512ES384, ES256K, PS256, RS512RS384, RS256, , RS384et RS512.

Exemples de code

Vérifie la signature par rapport au digest spécifié. S’abonne à l’appel de manière asynchrone et imprime les détails de vérification lorsqu’une réponse a été reçue.

byte[] myData = new byte[100];
 new Random(0x1234567L).nextBytes(myData);
 MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
 messageDigest.update(myData);
 byte[] myDigest = messageDigest.digest();

 // A signature can be obtained from the SignResult returned by the CryptographyAsyncClient.sign() operation.
 cryptographyAsyncClient.verify(SignatureAlgorithm.ES256, myDigest, signature)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(verifyResult ->
         System.out.printf("Verification status: %s.%n", verifyResult.isValid()));

Parameters:

algorithm - Algorithme à utiliser pour la signature.
digest - Contenu à partir duquel la signature a été créée.
signature - Signature à vérifier.

Returns:

Mono contenant un VerifyResultisValid().

verifyData

public Mono verifyData(SignatureAlgorithm algorithm, byte[] data, byte[] signature)

Vérifie une signature par rapport aux données brutes à l’aide de la clé configurée. L’opération de vérification prend en charge les clés symétriques et les clés asymétriques. Dans le cas de clés asymétriques, la partie publique de la clé est utilisée pour vérifier la signature. Cette opération nécessite l’autorisation pour les keys/verify opérations non locales.

indique SignatureAlgorithm le type d’algorithme à utiliser pour vérifier la signature. Les valeurs possibles sont les suivantes : ES256, ES512ES384, ES256K, PS256, RS512RS384, RS256, , RS384et RS512.

Exemples de code

Vérifie la signature par rapport aux données brutes. S’abonne à l’appel de manière asynchrone et imprime les détails de vérification lorsqu’une réponse a été reçue.

byte[] myData = new byte[100];
 new Random(0x1234567L).nextBytes(myData);

 // A signature can be obtained from the SignResult returned by the CryptographyAsyncClient.sign() operation.
 cryptographyAsyncClient.verify(SignatureAlgorithm.ES256, myData, signature)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(verifyResult ->
         System.out.printf("Verification status: %s.%n", verifyResult.isValid()));

Parameters:

algorithm - Algorithme à utiliser pour la signature.
data - Contenu brut sur lequel la signature doit être vérifiée.
signature - Signature à vérifier.

Returns:

Mono contenant un VerifyResultisValid().

wrapKey

public Mono wrapKey(KeyWrapAlgorithm algorithm, byte[] key)

Encapsule une clé symétrique à l’aide de la clé configurée. L’opération wrap prend en charge l’encapsulation d’une clé symétrique avec des clés symétriques et asymétriques. Cette opération nécessite l’autorisation pour les keys/wrapKey opérations non locales.

indique KeyWrapAlgorithm le type d’algorithme à utiliser pour l’encapsulage du contenu de clé spécifié. Les valeurs possibles sont les suivantes : RSA1_5, RSA_OAEP et RSA_OAEP_256. Les valeurs possibles pour les clés symétriques sont les suivantes : A128KW, A192KW et A256KW.

Exemples de code

Encapsule le contenu de la clé. S’abonne à l’appel de façon asynchrone et imprime les détails de la clé encapsulée lorsqu’une réponse a été reçue.

byte[] key = new byte[100];
 new Random(0x1234567L).nextBytes(key);

 cryptographyAsyncClient.wrapKey(KeyWrapAlgorithm.RSA_OAEP, key)
     .contextWrite(Context.of("key1", "value1", "key2", "value2"))
     .subscribe(wrapResult ->
         System.out.printf("Received encrypted key of length: %d, with algorithm: %s.%n",
             wrapResult.getEncryptedKey().length, wrapResult.getAlgorithm().toString()));

Parameters:

algorithm - Algorithme de chiffrement à utiliser pour l’encapsulage de la clé.
key - Contenu de clé à encapsuler.

Returns:

Mono contenant un WrapResult dont getEncryptedKey() contient le résultat de clé encapsulée.

S’applique à