Cleaned up cryptography code snippets for Key Vault Keys. (Azure#20680)

* Cleaned up cryptography code snippets.

* Added context back to async code snippets, but using `contextWrite()` instead of `subscriberContext()`.

* Moved the signature variable outside of the scope of code snippets for the Sign and Verify operations and added comments to provide clarity on where to obtain such a signature.

Author: vcolin7

sdk/keyvault/azure-security-keyvault-keys/src/samples/java/com/azure/security/keyvault/keys/cryptography/CryptographyAsyncClientJavaDocCodeSnippets.java

@@ -3,7 +3,6 @@
 
 package com.azure.security.keyvault.keys.cryptography;
 
-import com.azure.core.credential.TokenCredential;
 import com.azure.core.http.HttpClient;
 import com.azure.core.http.HttpPipeline;
 import com.azure.core.http.HttpPipelineBuilder;
@@ -12,10 +11,10 @@
 import com.azure.core.http.policy.RetryPolicy;
 import com.azure.identity.DefaultAzureCredentialBuilder;
 import com.azure.security.keyvault.keys.KeyAsyncClient;
-import com.azure.security.keyvault.keys.implementation.KeyVaultCredentialPolicy;
 import com.azure.security.keyvault.keys.cryptography.models.EncryptionAlgorithm;
 import com.azure.security.keyvault.keys.cryptography.models.KeyWrapAlgorithm;
 import com.azure.security.keyvault.keys.cryptography.models.SignatureAlgorithm;
+import com.azure.security.keyvault.keys.implementation.KeyVaultCredentialPolicy;
 import com.azure.security.keyvault.keys.models.JsonWebKey;
 
 import java.security.MessageDigest;
@@ -26,10 +25,10 @@
  * This class contains code samples for generating javadocs through doclets for {@link KeyAsyncClient}.
  */
 public final class CryptographyAsyncClientJavaDocCodeSnippets {
-    private String key1 = "key1";
-    private String key2 = "key2";
-    private String value1 = "val1";
-    private String value2 = "val2";
+    private final String key1 = "key1";
+    private final String key2 = "key2";
+    private final String value1 = "val1";
+    private final String value2 = "val2";
 
     /**
      * Generates code sample for creating a {@link KeyAsyncClient}.
@@ -39,10 +38,11 @@ public final class CryptographyAsyncClientJavaDocCodeSnippets {
     public CryptographyAsyncClient createAsyncClient() {
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.instantiation
         CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
-            .keyIdentifier("<YOUR-KEY-ID>")
+            .keyIdentifier("<your-key-id>")
             .credential(new DefaultAzureCredentialBuilder().build())
             .buildAsyncClient();
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.instantiation
+
         return cryptographyAsyncClient;
     }
 
@@ -54,11 +54,11 @@ public CryptographyAsyncClient createAsyncClient() {
     public CryptographyAsyncClient createAsyncClientWithJsonWebKey() {
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.withJsonWebKey.instantiation
         JsonWebKey jsonWebKey = new JsonWebKey().setId("SampleJsonWebKey");
-
         CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
             .jsonWebKey(jsonWebKey)
             .buildAsyncClient();
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.withJsonWebKey.instantiation
+
         return cryptographyAsyncClient;
     }
 
@@ -70,12 +70,13 @@ public CryptographyAsyncClient createAsyncClientWithJsonWebKey() {
     public CryptographyAsyncClient createAsyncClientWithHttpClient() {
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.withHttpClient.instantiation
         CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
-            .keyIdentifier("<Your-Key-ID>")
+            .keyIdentifier("<your-key-id>")
             .httpLogOptions(new HttpLogOptions().setLogLevel(HttpLogDetailLevel.BODY_AND_HEADERS))
             .addPolicy(new KeyVaultCredentialPolicy(new DefaultAzureCredentialBuilder().build()))
             .httpClient(HttpClient.createDefault())
             .buildAsyncClient();
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.withHttpClient.instantiation
+
         return cryptographyAsyncClient;
     }
 
@@ -91,9 +92,10 @@ public CryptographyAsyncClient createAsyncClientWithPipeline() {
             .build();
         CryptographyAsyncClient cryptographyAsyncClient = new CryptographyClientBuilder()
             .pipeline(pipeline)
-            .keyIdentifier("<YOUR-KEY-ID")
+            .keyIdentifier("<your-key-id>")
             .buildAsyncClient();
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.withPipeline.instantiation
+
         return cryptographyAsyncClient;
     }
 
@@ -102,10 +104,12 @@ public CryptographyAsyncClient createAsyncClientWithPipeline() {
      */
     public void getKeySnippets() {
         CryptographyAsyncClient cryptographyAsyncClient = createAsyncClient();
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.getKey
         cryptographyAsyncClient.getKey()
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
-            .subscribe(key -> System.out.printf("Key is returned with name %s and id %s \n", key.getName(), key.getId()));
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
+            .subscribe(key -> System.out.printf("Key returned with name: %s, and id: %s.\n", key.getName(),
+                key.getId()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.getKey
     }
 
@@ -114,10 +118,11 @@ public void getKeySnippets() {
      */
     public void getKeyWithResponseSnippets() {
         CryptographyAsyncClient cryptographyAsyncClient = createAsyncClient();
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.getKeyWithResponse
         cryptographyAsyncClient.getKeyWithResponse()
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
-            .subscribe(keyResponse -> System.out.printf("Key is returned with name %s and id %s \n",
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
+            .subscribe(keyResponse -> System.out.printf("Key returned with name: %s, and id: %s.\n",
                 keyResponse.getValue().getName(), keyResponse.getValue().getId()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.getKeyWithResponse
     }
@@ -134,27 +139,26 @@ public void encrypt() {
         new Random(0x1234567L).nextBytes(plaintext);
 
         cryptographyAsyncClient.encrypt(EncryptionAlgorithm.RSA_OAEP, plaintext)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(encryptResult ->
-                System.out.printf("Received encrypted content of length %d with algorithm %s \n",
+                System.out.printf("Received encrypted content of length: %d, with algorithm: %s.\n",
                     encryptResult.getCipherText().length, encryptResult.getAlgorithm().toString()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.encrypt#EncryptionAlgorithm-byte
 
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.encrypt#EncryptParameters
         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)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(encryptResult ->
-                System.out.printf("Received encrypted content of length %d with algorithm %s \n",
+                System.out.printf("Received encrypted content of length: %d, with algorithm: %s.\n",
                     encryptResult.getCipherText().length, encryptResult.getAlgorithm().toString()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.encrypt#EncryptParameters
     }
@@ -168,30 +172,28 @@ public void decrypt() {
 
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.decrypt#EncryptionAlgorithm-byte
         byte[] ciphertext = new byte[100];
-
         new Random(0x1234567L).nextBytes(ciphertext);
 
         cryptographyAsyncClient.decrypt(EncryptionAlgorithm.RSA_OAEP, ciphertext)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(decryptResult ->
-                System.out.printf("Received decrypted content of length %d\n", decryptResult.getPlainText().length));
+                System.out.printf("Received decrypted content of length: %d\n", decryptResult.getPlainText().length));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.decrypt#EncryptionAlgorithm-byte
 
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.decrypt#DecryptParameters
         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)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(decryptResult ->
-                System.out.printf("Received decrypted content of length %d\n", decryptResult.getPlainText().length));
+                System.out.printf("Received decrypted content of length: %d.\n", decryptResult.getPlainText().length));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.decrypt#DecryptParameters
     }
 
@@ -203,24 +205,35 @@ public void decrypt() {
      */
     public void signVerify() throws NoSuchAlgorithmException {
         CryptographyAsyncClient cryptographyAsyncClient = createAsyncClient();
-        byte[] signature = new byte[100];
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.sign#SignatureAlgorithm-byte
         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)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(signResult ->
-                System.out.printf("Received signature of length %d with algorithm %s", signResult.getSignature().length));
+                System.out.printf("Received signature of length: %d, with algorithm: %s.\n",
+                    signResult.getSignature().length, signResult.getAlgorithm()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.sign#SignatureAlgorithm-byte
 
+        byte[] signature = new byte[100];
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.verify#SignatureAlgorithm-byte-byte
-        cryptographyAsyncClient.verify(SignatureAlgorithm.ES256, digest, signature)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+        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 -> context.put(key1, value1).put(key2, value2))
             .subscribe(verifyResult ->
-                System.out.printf("Verification status %s", verifyResult.isValid()));
+                System.out.printf("Verification status: %s.\n", verifyResult.isValid()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.verify#SignatureAlgorithm-byte-byte
     }
 
@@ -231,25 +244,28 @@ public void signVerify() throws NoSuchAlgorithmException {
      */
     public void wrapKeyUnwrapKey() {
         CryptographyAsyncClient cryptographyAsyncClient = createAsyncClient();
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.wrapKey#KeyWrapAlgorithm-byte
         byte[] key = new byte[100];
         new Random(0x1234567L).nextBytes(key);
 
         cryptographyAsyncClient.wrapKey(KeyWrapAlgorithm.RSA_OAEP, key)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
-            .subscribe(keyWrapResult ->
-                System.out.printf("Received encypted key of length %d with algorithm %s",
-                    keyWrapResult.getEncryptedKey().length, keyWrapResult.getAlgorithm().toString()));
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
+            .subscribe(wrapResult ->
+                System.out.printf("Received encrypted key of length: %d, with algorithm: %s.\n",
+                    wrapResult.getEncryptedKey().length, wrapResult.getAlgorithm().toString()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.wrapKey#KeyWrapAlgorithm-byte
 
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.unwrapKey#KeyWrapAlgorithm-byte
-        byte[] wrappedKey = new byte[100];
+        byte[] keyToWrap = new byte[100];
         new Random(0x1234567L).nextBytes(key);
 
-        cryptographyAsyncClient.unwrapKey(KeyWrapAlgorithm.RSA_OAEP, wrappedKey)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
-            .subscribe(keyUnwrapResult ->
-                System.out.printf("Received key of length %d", keyUnwrapResult.getKey().length));
+        cryptographyAsyncClient.wrapKey(KeyWrapAlgorithm.RSA_OAEP, keyToWrap)
+            .contextWrite(context -> context.put(key1, value1).put(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)));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.unwrapKey#KeyWrapAlgorithm-byte
     }
 
@@ -261,31 +277,29 @@ public void wrapKeyUnwrapKey() {
      */
     public void signDataVerifyData() throws NoSuchAlgorithmException {
         CryptographyAsyncClient cryptographyAsyncClient = createAsyncClient();
-        byte[] signature = new byte[100];
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.signData#SignatureAlgorithm-byte
         byte[] data = new byte[100];
         new Random(0x1234567L).nextBytes(data);
 
         cryptographyAsyncClient.sign(SignatureAlgorithm.ES256, data)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+            .contextWrite(context -> context.put(key1, value1).put(key2, value2))
             .subscribe(signResult ->
-                System.out.printf("Received signature of length %d with algorithm %s", signResult.getSignature().length));
+                System.out.printf("Received signature of length: %d, with algorithm: %s.\n",
+                    signResult.getSignature().length, signResult.getAlgorithm()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.signData#SignatureAlgorithm-byte
 
+        byte[] signature = new byte[100];
+
         // BEGIN: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.verifyData#SignatureAlgorithm-byte-byte
-        cryptographyAsyncClient.verify(SignatureAlgorithm.ES256, data, signature)
-            .subscriberContext(reactor.util.context.Context.of(key1, value1, key2, value2))
+        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 -> context.put(key1, value1).put(key2, value2))
             .subscribe(verifyResult ->
-                System.out.printf("Verification status %s", verifyResult.isValid()));
+                System.out.printf("Verification status: %s.\n", verifyResult.isValid()));
         // END: com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient.verifyData#SignatureAlgorithm-byte-byte
     }
-
-    /**
-     * Implementation not provided for this method.
-     *
-     * @return {@code null}.
-     */
-    private TokenCredential getKeyVaultCredential() {
-        return null;
-    }
 }