Criptografia do lado do cliente e o Cofre da Chave do Azure para o Armazenamento do Microsoft AzureClient-Side Encryption and Azure Key Vault for Microsoft Azure Storage

Visão geralOverview

A biblioteca de cliente de armazenamento do Azure para .net dá suporte à criptografia de dados em aplicativos cliente antes do carregamento no armazenamento do Azure e à descriptografia de dados durante o download para o cliente.The Azure Storage Client Library for .NET supports encrypting data within client applications before uploading to Azure Storage, and decrypting data while downloading to the client. A biblioteca também dá suporte à integração com o Cofre da Chave do Azure para o gerenciamento de chaves de contas de armazenamento.The library also supports integration with Azure Key Vault for storage account key management.

Para obter um tutorial passo a passo que orienta você pelo processo de criptografia de blobs usando criptografia do lado do cliente e o Cofre da Chave do Azure, confira Criptografar e descriptografar blobs no Armazenamento do Microsoft Azure usando a Chave do Cofre do Azure.For a step-by-step tutorial that leads you through the process of encrypting blobs using client-side encryption and Azure Key Vault, see Encrypt and decrypt blobs in Microsoft Azure Storage using Azure Key Vault.

Para a criptografia do lado do cliente com Java, veja Criptografia do lado do cliente com Java para o Armazenamento do Microsoft Azure.For client-side encryption with Java, see Client-Side Encryption with Java for Microsoft Azure Storage.

Criptografia e descriptografia com a técnica de envelopeEncryption and decryption via the envelope technique

Os processos de criptografia e descriptografia seguem a técnica de envelope.The processes of encryption and decryption follow the envelope technique.

Criptografia com a técnica de envelopeEncryption via the envelope technique

A criptografia com a técnica de envelope funciona da seguinte maneira:Encryption via the envelope technique works in the following way:

  1. A biblioteca do cliente do Armazenamento do Azure gera um CEK (Chave de Criptografia de Conteúdo) que é uma chave simétrica de uso único.The Azure storage client library generates a content encryption key (CEK), which is a one-time-use symmetric key.

  2. Os dados do usuário são criptografados usando esse CEK.User data is encrypted using this CEK.

  3. O CEK é empacotada (criptografada) usando o KEK (Chave de Criptografia de Chave).The CEK is then wrapped (encrypted) using the key encryption key (KEK). O KEK é identificado por um identificador de chave e pode ser um par de chaves assimétricas ou uma chave simétrica e pode ser gerenciada localmente ou armazenada no Cofre da Chave do Azure.The KEK is identified by a key identifier and can be an asymmetric key pair or a symmetric key and can be managed locally or stored in Azure Key Vaults.

    A biblioteca de cliente de armazenamento em si nunca tem acesso ao KEK.The storage client library itself never has access to KEK. Ela simplesmente invoca o algoritmo de disposição de chave fornecido pelo Cofre da Chave.The library invokes the key wrapping algorithm that is provided by Key Vault. Os usuários podem escolher usar provedores personalizados para desempacotamento/quebra da chave, se desejado.Users can choose to use custom providers for key wrapping/unwrapping if desired.

  4. Os dados criptografados, em seguida, são carregados para o serviço de Armazenamento do Azure.The encrypted data is then uploaded to the Azure Storage service. A chave empacotada junto com alguns metadados adicionais de criptografia está armazenada como metadados (em um blob) ou interpolada com os dados criptografados (fila de mensagens e entidades de tabela).The wrapped key along with some additional encryption metadata is either stored as metadata (on a blob) or interpolated with the encrypted data (queue messages and table entities).

Descriptografia com a técnica de envelopeDecryption via the envelope technique

A descriptografia com a técnica de envelope funciona da seguinte maneira:Decryption via the envelope technique works in the following way:

  1. A biblioteca de cliente presume que o usuário está gerenciando o KEK (chave de criptografia de chave) localmente ou no Cofre da Chave do Azure.The client library assumes that the user is managing the key encryption key (KEK) either locally or in Azure Key Vaults. O usuário não precisa conhecer a chave específica que foi usada para criptografia.The user does not need to know the specific key that was used for encryption. Em vez disso, um resolvedor de chave que resolve diferentes identificadores de chaves pode ser configurado e usado.Instead, a key resolver which resolves different key identifiers to keys can be set up and used.
  2. A biblioteca de cliente baixa os dados criptografados junto com demais materiais de criptografia armazenados no serviço.The client library downloads the encrypted data along with any encryption material that is stored on the service.
  3. O CEK (chave de criptografia de conteúdo) empacotado é então desempacotado usando KEK.The wrapped content encryption key (CEK) is then unwrapped (decrypted) using the key encryption key (KEK). Novamente aqui, a biblioteca de cliente não tem acesso a KEK.Here again, the client library does not have access to KEK. Ela simplesmente invoca o algoritmo de descompactação do provedor do Key Vault ou personalizado.It simply invokes the custom or Key Vault provider's unwrapping algorithm.
  4. A CEK (chave de criptografia de conteúdo) é então usada para descriptografar os dados de usuário criptografados.The content encryption key (CEK) is then used to decrypt the encrypted user data.

Mecanismo de criptografiaEncryption Mechanism

A biblioteca de cliente de armazenamento usa AES para criptografar os dados do usuário.The storage client library uses AES in order to encrypt user data. Especificamente, o modo CBC (Encadeamento de Blocos de Criptografia) com AES.Specifically, Cipher Block Chaining (CBC) mode with AES. Cada serviço funciona ligeiramente diferente, portanto, discutiremos cada uma deles aqui.Each service works somewhat differently, so we will discuss each of them here.

BlobsBlobs

Atualmente, a biblioteca de cliente dá suporte à criptografia somente de blobs completos.The client library currently supports encryption of whole blobs only. Especificamente, há suporte para a criptografia quando os usuários usam os métodos uploadfrom ou o método OpenWrite .Specifically, encryption is supported when users use the UploadFrom methods or the OpenWrite method. Para downloads, tanto os downloads completos quanto os de intervalo têm suporte.For downloads, both complete and range downloads are supported.

Durante a criptografia, a biblioteca de cliente gerará um vetor de inicialização aleatório (IV) de 16 bytes, juntamente com uma chave de criptografia aleatória de conteúdo (CEK) de 32 bytes e executará a criptografia de envelope dos dados blob usando essas informações.During encryption, the client library will generate a random Initialization Vector (IV) of 16 bytes, together with a random content encryption key (CEK) of 32 bytes, and perform envelope encryption of the blob data using this information. O CEK encapsulado e alguns metadados adicionais de criptografia são armazenadas como metadados com o blob criptografado no serviço de blob.The wrapped CEK and some additional encryption metadata are then stored as blob metadata along with the encrypted blob on the service.

Aviso

Se você estiver editando ou carregando seus próprios metadados para o blob, deverá garantir que esses metadados sejam preservado.If you are editing or uploading your own metadata for the blob, you need to ensure that this metadata is preserved. Se você carregar novos metadados sem esses metadados, o CEK encapsulado, IV e outros metadados serão perdidos e o conteúdo do blob nunca mais poderá ser recuperado.If you upload new metadata without this metadata, the wrapped CEK, IV, and other metadata will be lost and the blob content will never be retrievable again.

O download de um blob criptografado envolve a recuperação do conteúdo do blob inteiro usando os métodos de conveniência downloadto/BlobReadStream .Downloading an encrypted blob involves retrieving the content of the entire blob using the DownloadTo/BlobReadStream convenience methods. O CEK encapsulado é desempacotado e usado em conjunto com o IV (armazenado como metadados de blob neste caso) para retornar os dados descriptografados para os usuários.The wrapped CEK is unwrapped and used together with the IV (stored as blob metadata in this case) to return the decrypted data to the users.

O download de um intervalo arbitrário (métodosmétodos downloadrange ) no blob criptografado envolve o ajuste do intervalo fornecido pelos usuários para obter uma pequena quantidade de dados adicionais que podem ser usados para descriptografar com êxito o intervalo solicitado.Downloading an arbitrary range (DownloadRange methods) in the encrypted blob involves adjusting the range provided by users in order to get a small amount of additional data that can be used to successfully decrypt the requested range.

Todos os tipos de blob (blobs de blocos, blobs de páginas e blobs de anexo) podem ser criptografados/descriptografados usando este esquema.All blob types (block blobs, page blobs, and append blobs) can be encrypted/decrypted using this scheme.

FilasQueues

Uma vez que a fila de mensagens pode ser de qualquer formato, a biblioteca de cliente define um formato personalizado que inclui o vetor de inicialização (IV) e a chave de criptografia do conteúdo criptografado (CEK) no texto da mensagem.Since queue messages can be of any format, the client library defines a custom format that includes the Initialization Vector (IV) and the encrypted content encryption key (CEK) in the message text.

Durante a criptografia, a biblioteca de cliente gera um IV aleatório de 16 bytes com um CEK aleatória de 32 bytes e executa criptografia de envelope do texto da mensagem de fila usando essas informações.During encryption, the client library generates a random IV of 16 bytes along with a random CEK of 32 bytes and performs envelope encryption of the queue message text using this information. O CEK encapsulado e alguns metadados adicionais de criptografia são adicionados à mensagem da fila criptografada.The wrapped CEK and some additional encryption metadata are then added to the encrypted queue message. Essa mensagem modificada (mostrada abaixo) é armazenada no serviço.This modified message (shown below) is stored on the service.

<MessageText>{"EncryptedMessageContents":"6kOu8Rq1C3+M1QO4alKLmWthWXSmHV3mEfxBAgP9QGTU++MKn2uPq3t2UjF1DO6w","EncryptionData":{…}}</MessageText>

Durante a descriptografia, a chave encapsulada é extraída da mensagem da fila e envolta.During decryption, the wrapped key is extracted from the queue message and unwrapped. O IV também é extraído da mensagem da fila e usado juntamente com a chave desencapsulada para descriptografar os dados de mensagem da fila.The IV is also extracted from the queue message and used along with the unwrapped key to decrypt the queue message data. Observe que os metadados de criptografia são pequeno (abaixo de 500 bytes), por isso embora contem para o limite de 64 KB para uma mensagem da fila, tal impacto é administrável.Note that the encryption metadata is small (under 500 bytes), so while it does count toward the 64KB limit for a queue message, the impact should be manageable.

TabelasTables

A biblioteca de cliente dá suporte à criptografia de propriedades de entidade para as operações de inserção e substituição.The client library supports encryption of entity properties for insert and replace operations.

Observação

Atualmente não há suporte para a mesclagem.Merge is not currently supported. Como um subconjunto de propriedades pode ter sido criptografado anteriormente usando uma chave diferente, simplesmente mesclar as novas propriedades e atualizar os metadados resultará em perda de dados.Since a subset of properties may have been encrypted previously using a different key, simply merging the new properties and updating the metadata will result in data loss. Mesclar requer fazer chamadas de serviço extra para ler a entidade já existente no serviço ou usar uma nova chave por propriedade, os quais não são ambos adequados por motivos de desempenho.Merging either requires making extra service calls to read the pre-existing entity from the service, or using a new key per property, both of which are not suitable for performance reasons.

Criptografia de dados de tabela funciona da seguinte maneira:Table data encryption works as follows:

  1. Os usuários especificam as propriedades que devem ser criptografadas.Users specify the properties to be encrypted.
  2. A biblioteca de cliente gera um vetor de inicialização aleatório (IV) de 16 bytes com uma chave de criptografia aleatória de conteúdo (CEK) de 32 bytes para cada entidade e executa a criptografia de envelope sobre as propriedades individuais que devem ser criptografadas, derivando uma nova IV por propriedade.The client library generates a random Initialization Vector (IV) of 16 bytes along with a random content encryption key (CEK) of 32 bytes for every entity, and performs envelope encryption on the individual properties to be encrypted by deriving a new IV per property. A propriedade criptografada é armazenada como dados binários.The encrypted property is stored as binary data.
  3. O CEK encapsulado e alguns metadados adicionais de criptografia, em seguida, são armazenados como duas propriedades reservadas adicionais.The wrapped CEK and some additional encryption metadata are then stored as two additional reserved properties. A primeira propriedade reservada (_ClientEncryptionMetadata1) é uma propriedade de cadeia de caracteres que contém informações sobre o IV, versão e chave encapsuladas.The first reserved property (_ClientEncryptionMetadata1) is a string property that holds the information about IV, version, and wrapped key. A segunda propriedade reservada (_ClientEncryptionMetadata2) é uma propriedade binária que armazena as informações sobre as propriedades criptografadas.The second reserved property (_ClientEncryptionMetadata2) is a binary property that holds the information about the properties that are encrypted. As informações nessa segunda propriedade (_ClientEncryptionMetadata2) são criptografadas.The information in this second property (_ClientEncryptionMetadata2) is itself encrypted.
  4. Devido a essas propriedades reservadas adicionais necessárias para a criptografia, os usuários agora podem ter apenas 250 propriedades personalizadas, em vez de 252.Due to these additional reserved properties required for encryption, users may now have only 250 custom properties instead of 252. O tamanho total da entidade deve ser inferior a 1 MB.The total size of the entity must be less than 1 MB.

Observe que somente as propriedades de cadeia de caracteres podem ser criptografadas.Note that only string properties can be encrypted. Se outros tipos de propriedades precisarem ser criptografados, elas devem ser convertidas em cadeias de caracteres.If other types of properties are to be encrypted, they must be converted to strings. As cadeias de caracteres criptografadas são armazenadas no serviço como propriedades binárias, e são convertidas novamente em cadeias de caracteres após a descriptografia.The encrypted strings are stored on the service as binary properties, and they are converted back to strings after decryption.

Para tabelas, além da política de criptografia, os usuários devem especificar as propriedades que devem ser criptografadas.For tables, in addition to the encryption policy, users must specify the properties to be encrypted. Isso pode ser feito especificando o atributo [EncryptProperty] (para entidades POCO que derivam de TableEntity) ou um resolvedor de criptografia nas opções de solicitação.This can be done by either specifying an [EncryptProperty] attribute (for POCO entities that derive from TableEntity) or an encryption resolver in request options. Um resolvedor de criptografia é um delegado que usa uma chave de partição, a chave de linha e o nome da propriedade e retorna um valor booliano que indica se essa propriedade deve ser criptografada.An encryption resolver is a delegate that takes a partition key, row key, and property name and returns a Boolean that indicates whether that property should be encrypted. Durante a criptografia, a biblioteca de cliente usará essas informações para decidir se uma propriedade deve ser criptografada durante a gravação para a transmissão.During encryption, the client library will use this information to decide whether a property should be encrypted while writing to the wire. O representante também oferece a possibilidade de lógica em torno de como as propriedades são criptografadas.The delegate also provides for the possibility of logic around how properties are encrypted. (Por exemplo, se X, então criptografar a propriedade A; caso contrário, criptografar as propriedades A e B.) Observe que não é necessário fornecer essas informações durante a leitura ou ap consultar entidades.(For example, if X, then encrypt property A; otherwise encrypt properties A and B.) Note that it is not necessary to provide this information while reading or querying entities.

Operações em loteBatch Operations

Em operações em lote, o mesmo KEK será usado em todas as linhas de operação em lote porque a biblioteca de cliente permite apenas um objeto de opções (e, portanto, uma política/KEK) por operação em lote.In batch operations, the same KEK will be used across all the rows in that batch operation because the client library only allows one options object (and hence one policy/KEK) per batch operation. No entanto, a biblioteca de cliente gerará internamente um novo IV e CEK aleatórios por linha no lote.However, the client library will internally generate a new random IV and random CEK per row in the batch. Os usuários também podem optar por criptografar propriedades diferentes para cada operação em lote definindo esse comportamento no resolvedor de criptografia.Users can also choose to encrypt different properties for every operation in the batch by defining this behavior in the encryption resolver.

ConsultasQueries

Observação

Como as entidades são criptografadas, é possível executar consultas que filtram uma propriedade criptografada.Because the entities are encrypted, you cannot run queries that filter on an encrypted property. Se você tentar, os resultados estarão incorretos, porque o serviço tentará comparar dados criptografados com dados não criptografados.If you try, results will be incorrect, because the service would be trying to compare encrypted data with unencrypted data.

Para executar operações de consulta, você deve especificar que um resolvedor de chave é capaz de resolver todas as chaves no conjunto de resultados.To perform query operations, you must specify a key resolver that is able to resolve all the keys in the result set. Se uma entidade contida no resultado da consulta não puder ser resolvida para um provedor, a biblioteca de cliente gerará um erro.If an entity contained in the query result cannot be resolved to a provider, the client library will throw an error. Para qualquer consulta que realiza as projeções do lado do servidor, a biblioteca de cliente adicionará as propriedades de metadados de criptografia especial (_ClientEncryptionMetadata1 e ClientEncryptionMetadata2) por padrão às colunas selecionadas.For any query that performs server-side projections, the client library will add the special encryption metadata properties (_ClientEncryptionMetadata1 and _ClientEncryptionMetadata2) by default to the selected columns.

Azure Key VaultAzure Key Vault

O Cofre da Chave do Azure ajuda a proteger chaves criptográficas e segredos usados por aplicativos e serviços em nuvem.Azure Key Vault helps safeguard cryptographic keys and secrets used by cloud applications and services. Usando o Cofre da Chave do Azure, os usuários podem criptografar chaves e segredos (como chaves de autenticação, chaves de conta de armazenamento, chaves de criptografia de dados, arquivos .PFX e senhas) usando chaves que são protegidas por HSMs (módulos de segurança de hardware).By using Azure Key Vault, users can encrypt keys and secrets (such as authentication keys, storage account keys, data encryption keys, .PFX files, and passwords) by using keys that are protected by hardware security modules (HSMs). Para obter mais informações, veja O que é o Cofre da Chave do Azure?.For more information, see What is Azure Key Vault?.

A biblioteca de cliente de armazenamento usa a biblioteca principal do Cofre da Chave para fornecer uma estrutura comum no Azure para o gerenciamento de chaves.The storage client library uses the Key Vault core library in order to provide a common framework across Azure for managing keys. Os usuários também recebem o benefício adicional de usar a biblioteca de extensões do Cofre da Chave.Users also get the additional benefit of using the Key Vault extensions library. A biblioteca de extensões fornece funcionalidades úteis com Symmetric simples/RSA local e provedores de chave de nuvem e com agregação e armazenamento em cache.The extensions library provides useful functionality around simple and seamless Symmetric/RSA local and cloud key providers as well as with aggregation and caching.

Interface e dependênciasInterface and dependencies

Há três pacotes do Cofre da Chave:There are three Key Vault packages:

  • Microsoft.Azure.KeyVault.Core contém IKey e IKeyResolver.Microsoft.Azure.KeyVault.Core contains the IKey and IKeyResolver. Este é um pequeno pacote sem dependências.It is a small package with no dependencies. A biblioteca de cliente de armazenamento para .NET define isso como uma dependência.The storage client library for .NET defines it as a dependency.
  • Microsoft.Azure.KeyVault contém o cliente REST do Cofre da Chave.Microsoft.Azure.KeyVault contains the Key Vault REST client.
  • Microsoft.Azure.KeyVault.Extensions contém o código de extensão que inclui implementações de algoritmos criptográficos e um RSAKey e SymmetricKey.Microsoft.Azure.KeyVault.Extensions contains extension code that includes implementations of cryptographic algorithms and an RSAKey and a SymmetricKey. Ele depende dos namespaces básicos e KeyVault, e fornece a funcionalidade para definir um resolvedor de agregação (quando os usuários desejam usar vários provedores de chave) e um resolvedor de chave em cache.It depends on the Core and KeyVault namespaces and provides functionality to define an aggregate resolver (when users want to use multiple key providers) and a caching key resolver. Embora a biblioteca de cliente de armazenamento não dependa diretamente deste pacote, se os usuários quiserem usar o Cofre da Chave do Azure para armazenar suas chaves ou usar as extensões do Cofre da Chave para consumir provedores criptográficos local e na nuvem, eles precisarão esse pacote.Although the storage client library does not directly depend on this package, if users wish to use Azure Key Vault to store their keys or to use the Key Vault extensions to consume the local and cloud cryptographic providers, they will need this package.

O Cofre da Chave foi criado para chaves mestras de alto valor e os limites por Cofre da Chave são criados com tal prioridade em mente.Key Vault is designed for high-value master keys, and throttling limits per Key Vault are designed with this in mind. Ao executar a criptografia do lado do cliente com o Cofre da Chave, o modelo preferido é usar chaves mestras simétricas armazenadas como segredos no Cofre da Chave e armazenadas em cache localmente.When performing client-side encryption with Key Vault, the preferred model is to use symmetric master keys stored as secrets in Key Vault and cached locally. Os usuários devem fazer o seguinte:Users must do the following:

  1. Crie um segredo offline e carregue-o no Cofre da Chave.Create a secret offline and upload it to Key Vault.
  2. Use o identificador de base do segredo como um parâmetro para resolver a versão atual do segredo para criptografia e armazenar essas informações localmente em cache.Use the secret's base identifier as a parameter to resolve the current version of the secret for encryption and cache this information locally. Use CachingKeyResolver para armazenamento em cache. Os usuários não deverão implementar sua própria lógica de cache.Use CachingKeyResolver for caching; users are not expected to implement their own caching logic.
  3. Use o resolvedor de cache como uma entrada ao criar a política de criptografia.Use the caching resolver as an input while creating the encryption policy.

Mais informações sobre o uso do Cofre da Chave podem ser encontradas nos exemplos de código de criptografia.More information regarding Key Vault usage can be found in the encryption code samples.

Práticas recomendadasBest practices

O suporte à criptografia está disponível somente na biblioteca de cliente de armazenamento para .NET.Encryption support is available only in the storage client library for .NET. Atualmente, o Windows Phone e o Tempo de Execução do Windows não dão suporte à criptografia.Windows Phone and Windows Runtime do not currently support encryption.

Importante

Lembre-se dos seguintes pontos importantes ao usar a criptografia no lado do cliente:Be aware of these important points when using client-side encryption:

  • Durante a leitura ou gravação de um blob criptografado, use comandos de carregamento de blob completos e comandos de download de blob completos/em intervalos.When reading from or writing to an encrypted blob, use whole blob upload commands and range/whole blob download commands. Evite gravar em um blob criptografado usando operações de protocolo tais como Put Block, Put Block List, Write Pages, Clear Pages ou Append Block; caso contrário, você poderá corromper o blob criptografado e torná-lo ilegível.Avoid writing to an encrypted blob using protocol operations such as Put Block, Put Block List, Write Pages, Clear Pages, or Append Block; otherwise you may corrupt the encrypted blob and make it unreadable.
  • Para tabelas, existe uma restrição semelhante.For tables, a similar constraint exists. Tenha cuidado para não atualizar propriedades criptografadas sem atualizar os metadados de criptografia.Be careful to not update encrypted properties without updating the encryption metadata.
  • Se você definir os metadados no blob criptografado, poderá substituir os metadados relacionados à criptografia necessários para a descriptografia, uma vez que a definição de metadados não é aditiva.If you set metadata on the encrypted blob, you may overwrite the encryption-related metadata required for decryption, since setting metadata is not additive. Isso também ocorre em instantâneos. Evite especificar metadados ao criar um instantâneo de um blob criptografado.This is also true for snapshots; avoid specifying metadata while creating a snapshot of an encrypted blob. Se for necessário definir os metadados, lembre-se de chamar o método FetchAttributes primeiro para obter os atuais metadados de criptografia e evite gravações simultâneas durante a definição dos metadados.If metadata must be set, be sure to call the FetchAttributes method first to get the current encryption metadata, and avoid concurrent writes while metadata is being set.
  • Habilite a propriedade RequireEncryption nas opções de solicitação padrão para os usuários que devem trabalhar somente com dados criptografados.Enable the RequireEncryption property in the default request options for users that should work only with encrypted data. Saiba mais logo abaixo.See below for more info.

API do cliente / InterfaceClient API / Interface

Ao criar um objeto EncryptionPolicy, os usuários podem fornecer somente uma chave (Implementando IKey), somente um resolvedor (Implementando IKeyResolver) ou ambos.While creating an EncryptionPolicy object, users can provide only a Key (implementing IKey), only a resolver (implementing IKeyResolver), or both. IKey é o tipo de chave básico que é identificado usando um identificador de chave e que fornece a lógica para empacotamente/desempacotamento.IKey is the basic key type that is identified using a key identifier and that provides the logic for wrapping/unwrapping. IKeyResolver é usado para resolver uma chave durante o processo de descriptografia.IKeyResolver is used to resolve a key during the decryption process. Ele define um método ResolveKey que retorna um IKey dado um certo identificador de chave.It defines a ResolveKey method that returns an IKey given a key identifier. Isso fornece aos usuários a capacidade de escolher entre várias chaves que são gerenciadas em vários locais.This provides users the ability to choose between multiple keys that are managed in multiple locations.

  • Para criptografia, a chave é usada sempre e a ausência de uma chave resultará em um erro.For encryption, the key is used always and the absence of a key will result in an error.
  • Para descriptografar:For decryption:
    • O resolvedor de chave é invocado se especificado para obter a chave.The key resolver is invoked if specified to get the key. Se o resolvedor for especificado, mas não tiver um mapeamento para o identificador de chave, um erro será gerado.If the resolver is specified but does not have a mapping for the key identifier, an error is thrown.
    • Se o resolvedor não for especificado, mas uma chave for especificada, a chave será usada se o identificador corresponder ao identificador da chave necessária.If resolver is not specified but a key is specified, the key is used if its identifier matches the required key identifier. Se o identificador não corresponder, um erro será gerado.If the identifier does not match, an error is thrown.

Os exemplos de código neste artigo demonstram a configuração de uma política de criptografia e o trabalho com os dados criptografados, mas não demonstram o trabalho com o Azure Key Vault.The code examples in this article demonstrate setting an encryption policy and working with encrypted data, but do not demonstrate working with Azure Key Vault. Os exemplos de criptografia no GitHub demonstram um cenário completo mais detalhado para blobs, filas e tabelas, juntamente com a integração do Key Vault.The encryption samples on GitHub demonstrate a more detailed end-to-end scenario for blobs, queues and tables, along with Key Vault integration.

Modo RequireEncryptionRequireEncryption mode

Os usuários podem habilitar opcionalmente um modo de operação no qual todos os downloads e uploads devem ser criptografados.Users can optionally enable a mode of operation where all uploads and downloads must be encrypted. Nesse modo, as tentativas de carregamento de dados sem uma política de criptografia ou o download de dados que não são criptografados no serviço falharão no cliente.In this mode, attempts to upload data without an encryption policy or download data that is not encrypted on the service will fail on the client. A propriedade RequireEncryption do objeto de opções da solicitação controla esse comportamento.The RequireEncryption property of the request options object controls this behavior. Se o seu aplicativo for criptografar todos os objetos armazenados no Armazenamento do Azure, é possível definir a propriedade RequireEncryption nas opções de solicitação padrão para o objeto de cliente do serviço.If your application will encrypt all objects stored in Azure Storage, then you can set the RequireEncryption property on the default request options for the service client object. Por exemplo, defina CloudBlobClient.DefaultRequestOptions.RequireEncryption como true para exigir criptografia de todas as operações executadas de blob executadas por meio desse objeto de cliente.For example, set CloudBlobClient.DefaultRequestOptions.RequireEncryption to true to require encryption for all blob operations performed through that client object.

Criptografia do serviço BlobBlob service encryption

Crie um objeto BlobEncryptionPolicy e o defina nas opções de solicitação (por API ou no nível do cliente usando DefaultRequestOptions).Create a BlobEncryptionPolicy object and set it in the request options (per API or at a client level by using DefaultRequestOptions). Todo o resto será tratado pela biblioteca de cliente internamente.Everything else will be handled by the client library internally.

// Create the IKey used for encryption.
 RsaKey key = new RsaKey("private:key1" /* key identifier */);

 // Create the encryption policy to be used for upload and download.
 BlobEncryptionPolicy policy = new BlobEncryptionPolicy(key, null);

 // Set the encryption policy on the request options.
 BlobRequestOptions options = new BlobRequestOptions() { EncryptionPolicy = policy };

 // Upload the encrypted contents to the blob.
 blob.UploadFromStream(stream, size, null, options, null);

 // Download and decrypt the encrypted contents from the blob.
 MemoryStream outputStream = new MemoryStream();
 blob.DownloadToStream(outputStream, null, options, null);

Criptografia do serviço FilaQueue service encryption

Crie um objeto QueueEncryptionPolicy e o defina nas opções de solicitação (por API ou no nível do cliente usando DefaultRequestOptions).Create a QueueEncryptionPolicy object and set it in the request options (per API or at a client level by using DefaultRequestOptions). Todo o resto será tratado pela biblioteca de cliente internamente.Everything else will be handled by the client library internally.

// Create the IKey used for encryption.
 RsaKey key = new RsaKey("private:key1" /* key identifier */);

 // Create the encryption policy to be used for upload and download.
 QueueEncryptionPolicy policy = new QueueEncryptionPolicy(key, null);

 // Add message
 QueueRequestOptions options = new QueueRequestOptions() { EncryptionPolicy = policy };
 queue.AddMessage(message, null, null, options, null);

 // Retrieve message
 CloudQueueMessage retrMessage = queue.GetMessage(null, options, null);

Criptografia do serviço TabelaTable service encryption

Além de criar uma política de criptografia e defini-la nas opções de solicitação, você precisa especificar um EncryptionResolver em TableRequestOptions ou definir o atributo [EncryptProperty] na entidade.In addition to creating an encryption policy and setting it on request options, you must either specify an EncryptionResolver in TableRequestOptions, or set the [EncryptProperty] attribute on the entity.

Usando o resolvedorUsing the resolver

// Create the IKey used for encryption.
 RsaKey key = new RsaKey("private:key1" /* key identifier */);

 // Create the encryption policy to be used for upload and download.
 TableEncryptionPolicy policy = new TableEncryptionPolicy(key, null);

 TableRequestOptions options = new TableRequestOptions()
 {
    EncryptionResolver = (pk, rk, propName) =>
     {
        if (propName == "foo")
         {
            return true;
         }
         return false;
     },
     EncryptionPolicy = policy
 };

 // Insert Entity
 currentTable.Execute(TableOperation.Insert(ent), options, null);

 // Retrieve Entity
 // No need to specify an encryption resolver for retrieve
 TableRequestOptions retrieveOptions = new TableRequestOptions()
 {
    EncryptionPolicy = policy
 };

 TableOperation operation = TableOperation.Retrieve(ent.PartitionKey, ent.RowKey);
 TableResult result = currentTable.Execute(operation, retrieveOptions, null);

Usando atributosUsing attributes

Como mencionado acima, se a entidade implementar TableEntity, as propriedades poderão ser decoradas com o atributo [EncryptProperty] em vez de especificar o EncryptionResolver.As mentioned above, if the entity implements TableEntity, then the properties can be decorated with the [EncryptProperty] attribute instead of specifying the EncryptionResolver.

[EncryptProperty]
 public string EncryptedProperty1 { get; set; }

Criptografia e desempenhoEncryption and performance

Observe que criptografar seu armazenamento de dados resulta em uma sobrecarga adicional no desempenho.Note that encrypting your storage data results in additional performance overhead. O IV e a chave de conteúdo devem ser gerados, o próprio conteúdo deve ser criptografado e os metadados adicionais devem ser formatados e carregados.The content key and IV must be generated, the content itself must be encrypted, and additional meta-data must be formatted and uploaded. Essa sobrecarga poderá variar dependendo da quantidade de dados que está sendo criptografada.This overhead will vary depending on the quantity of data being encrypted. Recomendamos que os clientes sempre testem seus aplicativos a fim de verificar o desempenho durante o desenvolvimento.We recommend that customers always test their applications for performance during development.

Próximas etapasNext steps