Partilhar via

CryptographyAsyncClient Classe

  • Referência
Pacote:
com.azure.security.keyvault.keys.cryptography
Artefato Maven:
com.azure:azure-security-keyvault-keys:4.7.3
  • java.lang.Object
    • com.azure.security.keyvault.keys.cryptography.CryptographyAsyncClient

public class CryptographyAsyncClient

O CryptographyAsyncClient fornece métodos assíncronos para executar operações criptográficas usando chaves assimétricas e simétricas. O cliente dá suporte a operações criptografar, descriptografar, encapsular, desencapsular chave, assinar e verificar usando a chave configurada.

Introdução

Para interagir com o serviço de Key Vault do Azure, você precisará criar uma instância da CryptographyAsyncClient classe , uma URL do cofre e um objeto de credencial.

Os exemplos mostrados neste documento usam um objeto de credencial chamado DefaultAzureCredential para autenticação, que é apropriado para a maioria dos cenários, incluindo ambientes locais de desenvolvimento e produção. Além disso, é recomendável usar uma identidade gerenciada para autenticação em ambientes de produção. Você pode encontrar mais informações sobre diferentes maneiras de autenticação e seus tipos de credenciais correspondentes na documentação da Identidade do Azure".

Exemplo: Construir cliente de criptografia assíncrona

O exemplo de código a seguir demonstra a criação de um CryptographyAsyncClient, usando o CryptographyClientBuilder para configurá-lo.

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

Criptografar Dados

O CryptographyAsyncClient pode ser usado para criptografar dados.

Exemplo de código:

O exemplo de código a seguir demonstra como criptografar dados de forma assíncrona usando a encrypt(EncryptionAlgorithm algorithm, byte[] plaintext) API.

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

Nota: Para obter o exemplo síncrono, consulte CryptographyClient.

Descriptografar dados

O CryptographyAsyncClient pode ser usado para descriptografar dados.

Exemplo de código:

O exemplo de código a seguir demonstra como descriptografar dados de forma assíncrona usando a decrypt(EncryptionAlgorithm algorithm, byte[] ciphertext) API.

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

Nota: Para obter o exemplo síncrono, consulte CryptographyClient.

Resumo do método

Modificador e tipo Método e descrição
Mono<DecryptResult> decrypt(DecryptParameters decryptParameters)

Descriptografa um único bloco de dados criptografados usando a chave configurada e o algoritmo especificado.
Mono<DecryptResult> decrypt(EncryptionAlgorithm algorithm, byte[] ciphertext)

Descriptografa um único bloco de dados criptografados usando a chave configurada e o algoritmo especificado.
Mono<EncryptResult> encrypt(EncryptParameters encryptParameters)

Criptografa uma sequência arbitrária de bytes usando a chave configurada.
Mono<EncryptResult> encrypt(EncryptionAlgorithm algorithm, byte[] plaintext)

Criptografa uma sequência arbitrária de bytes usando a chave configurada.
Mono<KeyVaultKey> getKey()

Obtém a parte pública da chave configurada.
Mono<Response<KeyVaultKey>> getKeyWithResponse()

Obtém a parte pública da chave configurada.
Mono<SignResult> sign(SignatureAlgorithm algorithm, byte[] digest)

Cria uma assinatura de um resumo usando a chave configurada.
Mono<SignResult> signData(SignatureAlgorithm algorithm, byte[] data)

Cria uma assinatura com base nos dados brutos usando a chave configurada.
Mono<UnwrapResult> unwrapKey(KeyWrapAlgorithm algorithm, byte[] encryptedKey)

Desencapsular uma chave simétrica usando a chave configurada que foi usada inicialmente para encapsular essa chave.
Mono<VerifyResult> verify(SignatureAlgorithm algorithm, byte[] digest, byte[] signature)

Verifica uma assinatura usando a chave configurada.
Mono<VerifyResult> verifyData(SignatureAlgorithm algorithm, byte[] data, byte[] signature)

Verifica uma assinatura em relação aos dados brutos usando a chave configurada.
Mono<WrapResult> wrapKey(KeyWrapAlgorithm algorithm, byte[] key)

Encapsula uma chave simétrica usando a chave configurada.

Métodos herdados de java.lang.Object

clone equals finalize getClass hashCode notify notifyAll toString wait wait wait

Detalhes do método

decrypt

public Mono decrypt(DecryptParameters decryptParameters)

Descriptografa um único bloco de dados criptografados usando a chave configurada e o algoritmo especificado. Observe que apenas um único bloco de dados pode ser descriptografado, o tamanho desse bloco depende da chave de destino e do algoritmo a ser usado. A operação de descriptografar tem suporte para chaves assimétricas e simétricas. Essa operação requer a keys/decrypt permissão para operações não locais.

O EncryptionAlgorithm indica o tipo de algoritmo a ser usado para descriptografar o conteúdo criptografado especificado. Os valores possíveis para chaves assimétricas incluem: RSA1_5e RSA_OAEP_256RSA_OAEP . Os valores possíveis para chaves simétricas incluem: A128CBC, A128CBCPAD, A128CBC_HS256, A128GCM, A192CBC, A192CBCPAD, A192CBC_HS384A192GCM, A256CBC, A256CBCPADe A256CBC_HS512A256GCM.

Exemplos de código

Descriptografa o conteúdo criptografado. Assina a chamada de forma assíncrona e imprime os detalhes do conteúdo descriptografado quando uma resposta é recebida.

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 - Os parâmetros a serem usados na operação de descriptografia. A Microsoft recomenda que você não use CBC sem primeiro garantir a integridade do texto cifrado usando um HMAC, por exemplo. Consulte Vulnerabilidades de tempo com descriptografia simétrica no modo CBC usando preenchimento para obter mais informações.

Returns:

Um Mono que contém o blob descriptografado.

decrypt

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

Descriptografa um único bloco de dados criptografados usando a chave configurada e o algoritmo especificado. Observe que apenas um único bloco de dados pode ser descriptografado, o tamanho desse bloco depende da chave de destino e do algoritmo a ser usado. A operação de descriptografar tem suporte para chaves assimétricas e simétricas. Essa operação requer a keys/decrypt permissão para operações não locais.

O EncryptionAlgorithm indica o tipo de algoritmo a ser usado para descriptografar o conteúdo criptografado especificado. Os valores possíveis para chaves assimétricas incluem: RSA1_5e RSA_OAEP_256RSA_OAEP . Os valores possíveis para chaves simétricas incluem: A128CBC, A128CBCPAD, A128CBC_HS256, A128GCM, A192CBC, A192CBCPAD, A192CBC_HS384A192GCM, A256CBC, A256CBCPADe A256CBC_HS512A256GCM.

Exemplos de código

Descriptografa o conteúdo criptografado. Assina a chamada de forma assíncrona e imprime os detalhes do conteúdo descriptografado quando uma resposta é recebida.

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 - O algoritmo a ser usado para descriptografia.
ciphertext - O conteúdo a ser descriptografado. A Microsoft recomenda que você não use CBC sem primeiro garantir a integridade do texto cifrado usando um HMAC, por exemplo. Consulte Vulnerabilidades de tempo com descriptografia simétrica no modo CBC usando preenchimento para obter mais informações.

Returns:

Um Mono que contém o blob descriptografado.

encrypt

public Mono encrypt(EncryptParameters encryptParameters)

Criptografa uma sequência arbitrária de bytes usando a chave configurada. Observe que a operação de criptografia dá suporte apenas a um único bloco de dados, cujo tamanho depende da chave de destino e do algoritmo de criptografia a ser usado. A operação de criptografia tem suporte para chaves simétricas e chaves assimétricas. No caso de chaves assimétricas, a parte pública da chave é usada para criptografia. Essa operação requer a keys/encrypt permissão para operações não locais.

O EncryptionAlgorithm indica o tipo de algoritmo a ser usado para criptografar o especificado plaintext. Os valores possíveis para chaves assimétricas incluem: RSA1_5e RSA_OAEP_256RSA_OAEP . Os valores possíveis para chaves simétricas incluem: A128CBC, A128CBCPAD, A128CBC_HS256, A128GCM, A192CBC, A192CBCPAD, A192CBC_HS384A192GCM, A256CBC, A256CBCPADe A256CBC_HS512A256GCM.

Exemplos de código

Criptografa o conteúdo. Assina a chamada de forma assíncrona e imprime os detalhes do conteúdo criptografado quando uma resposta é recebida.

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 - Os parâmetros a serem usados na operação de criptografia.

Returns:

Um Mono que contém um EncryptResult cujo getCipherText() contém o conteúdo criptografado.

encrypt

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

Criptografa uma sequência arbitrária de bytes usando a chave configurada. Observe que a operação de criptografia dá suporte apenas a um único bloco de dados, cujo tamanho depende da chave de destino e do algoritmo de criptografia a ser usado. A operação de criptografia tem suporte para chaves simétricas e chaves assimétricas. No caso de chaves assimétricas, a parte pública da chave é usada para criptografia. Essa operação requer a keys/encrypt permissão para operações não locais.

O EncryptionAlgorithm indica o tipo de algoritmo a ser usado para criptografar o especificado plaintext. Os valores possíveis para chaves assimétricas incluem: RSA1_5e RSA_OAEP_256RSA_OAEP . Os valores possíveis para chaves simétricas incluem: A128CBC, A128CBCPAD, A128CBC_HS256, A128GCM, A192CBC, A192CBCPAD, A192CBC_HS384A192GCM, A256CBC, A256CBCPADe A256CBC_HS512A256GCM.

Exemplos de código

Criptografa o conteúdo. Assina a chamada de forma assíncrona e imprime os detalhes do conteúdo criptografado quando uma resposta é recebida.

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 - O algoritmo a ser usado para criptografia.
plaintext - O conteúdo a ser criptografado.

Returns:

Um Mono que contém um EncryptResult cujo getCipherText() contém o conteúdo criptografado.

getKey

public Mono getKey()

Obtém a parte pública da chave configurada. A operação get key é aplicável a todos os tipos de chave e requer a keys/get permissão para operações não locais.

Exemplos de código

Obtém a chave configurada no cliente. Assina a chamada de forma assíncrona e imprime os detalhes da chave retornada quando uma resposta é recebida.

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:

Um Mono que contém o solicitado KeyVaultKey.

getKeyWithResponse

public Mono> getKeyWithResponse()

Obtém a parte pública da chave configurada. A operação get key é aplicável a todos os tipos de chave e requer a keys/get permissão para operações não locais.

Exemplos de código

Obtém a chave configurada no cliente. Assina a chamada de forma assíncrona e imprime os detalhes da chave retornada quando uma resposta é recebida.

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:

Um Mono que contém um Response<T> cujo value contém o solicitado KeyVaultKey.

sign

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

Cria uma assinatura de um resumo usando a chave configurada. A operação de sinal dá suporte a chaves assimétricas e simétricas. Essa operação requer a keys/sign permissão para operações não locais.

O SignatureAlgorithm indica o tipo de algoritmo a ser usado para criar a assinatura do resumo. Os valores possíveis incluem: ES256, ES384, ES512, ES256K, PS256, RS384, RS512RS256, RS384, e RS512.

Exemplos de código

Canta o resumo. Assina a chamada de forma assíncrona e imprime os detalhes da assinatura quando uma resposta é recebida.

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 - O algoritmo a ser usado para assinatura.
digest - O conteúdo do qual a assinatura deve ser criada.

Returns:

Um Mono que contém um SignResult cujo getSignature() contém a assinatura criada.

signData

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

Cria uma assinatura com base nos dados brutos usando a chave configurada. A operação de dados de sinal dá suporte a chaves assimétricas e simétricas. Essa operação requer a keys/sign permissão para operações não locais.

O SignatureAlgorithm indica o tipo de algoritmo a ser usado para assinar o resumo. Os valores possíveis incluem: ES256, ES384, ES512, ES256K, PS256, RS384, RS512RS256, RS384, e RS512.

Exemplos de código

Assina os dados brutos. Assina a chamada de forma assíncrona e imprime os detalhes da assinatura quando uma resposta é recebida.

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 - O algoritmo a ser usado para assinatura.
data - O conteúdo do qual a assinatura deve ser criada.

Returns:

Um Mono que contém um SignResult cujo getSignature() contém a assinatura criada.

unwrapKey

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

Desencapsular uma chave simétrica usando a chave configurada que foi usada inicialmente para encapsular essa chave. Essa operação é o inverso da operação de encapsulamento. A operação de desencapsular dá suporte a chaves assimétricas e simétricas para desencapsular. Essa operação requer a keys/unwrapKey permissão para operações não locais.

O KeyWrapAlgorithm indica o tipo de algoritmo a ser usado para desencapsular o conteúdo da chave criptografada especificado. Os valores possíveis para chaves assimétricas incluem: RSA1_5e RSA_OAEP_256RSA_OAEP . Os valores possíveis para chaves simétricas incluem: A128KWe A192KWA256KW.

Exemplos de código

Desencapsular o conteúdo da chave. Assina a chamada de forma assíncrona e imprime os detalhes da chave desencapsular quando uma resposta é recebida.

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 - O algoritmo de criptografia a ser usado para encapsular a chave.
encryptedKey - O conteúdo da chave criptografada a ser desencapsular.

Returns:

Um Mono que contém um UnwrapResult cujo decrypted key contém o resultado da chave desencapsulada.

verify

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

Verifica uma assinatura usando a chave configurada. A operação de verificação dá suporte a chaves simétricas e chaves assimétricas. No caso de chaves assimétricas, a parte pública da chave é usada para verificar a assinatura. Essa operação requer a keys/verify permissão para operações não locais.

O SignatureAlgorithm indica o tipo de algoritmo a ser usado para verificar a assinatura. Os valores possíveis incluem: ES256, ES384, ES512, ES256K, PS256, RS384, RS512RS256, RS384, e RS512.

Exemplos de código

Verifica a assinatura em relação ao resumo especificado. Assina a chamada de forma assíncrona e imprime os detalhes de verificação quando uma resposta é recebida.

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 - O algoritmo a ser usado para assinatura.
digest - O conteúdo do qual a assinatura foi criada.
signature - A assinatura a ser verificada.

Returns:

Um Mono que contém um VerifyResultisValid().

verifyData

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

Verifica uma assinatura em relação aos dados brutos usando a chave configurada. A operação de verificação dá suporte a chaves simétricas e chaves assimétricas. No caso de chaves assimétricas, a parte pública da chave é usada para verificar a assinatura. Essa operação requer a keys/verify permissão para operações não locais.

O SignatureAlgorithm indica o tipo de algoritmo a ser usado para verificar a assinatura. Os valores possíveis incluem: ES256, ES384, ES512, ES256K, PS256, RS384, RS512RS256, RS384, e RS512.

Exemplos de código

Verifica a assinatura em relação aos dados brutos. Assina a chamada de forma assíncrona e imprime os detalhes de verificação quando uma resposta é recebida.

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 - O algoritmo a ser usado para assinatura.
data - O conteúdo bruto em relação ao qual a assinatura deve ser verificada.
signature - A assinatura a ser verificada.

Returns:

Um Mono que contém um VerifyResultisValid().

wrapKey

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

Encapsula uma chave simétrica usando a chave configurada. A operação de encapsulamento dá suporte ao encapsulamento de uma chave simétrica com chaves simétricas e assimétricas. Essa operação requer a keys/wrapKey permissão para operações não locais.

O KeyWrapAlgorithm indica o tipo de algoritmo a ser usado para encapsular o conteúdo da chave especificado. Os valores possíveis incluem: RSA1_5e RSA_OAEPRSA_OAEP_256. Os valores possíveis para chaves simétricas incluem: A128KWe A192KWA256KW.

Exemplos de código

Encapsula o conteúdo da chave. Assina a chamada de forma assíncrona e imprime os detalhes da chave encapsulada quando uma resposta é recebida.

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 - O algoritmo de criptografia a ser usado para encapsular a chave.
key - O conteúdo da chave a ser encapsulado.

Returns:

Um Mono que contém um WrapResult cujo getEncryptedKey() contém o resultado da chave encapsulada.

Aplica-se a